Copyright © 2010 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark and document use rules apply.
VoID is an RDF Schema vocabulary for expressing metadata about RDF datasets. It is intended as a bridge between the publishers and users of RDF data, with applications ranging from data discovery to cataloging and archiving of datasets. This document is a detailed guide to the VoID vocabulary. It describes how VoID can be used to express general metadata based on Dublin Core, access metadata, structural metadata, and links between datasets. It also provides deployment advice and discusses the discovery of VoID descriptions.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
The document is submitted for consideration to the W3C's Semantic Web Interest Group (SWIG) to publish it as a W3C Interest Group Note. The SWIG does not expect this document to become a W3C Recommendation.
Publication as an Interest Group Note does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
Feedback on this document is welcome - please send comments to<EMAIL_ADDRESS>(with public archive). Additionally, we encourage to use the VoID issue tracker to record and track comments.
The IPR status of information provided in this document is in accordance with Section 6 of the W3C Patent Policy.
The disclosure obligations of the Participants of this group are described in the charter.
A first version of this document was developed and published by the authors, starting in 2008. This is an extended and improved version, based on community feedback received since the original publication.
The Vocabulary of Interlinked Datasets (VoID) is concerned with metadata about RDF datasets. It is an RDF Schema vocabulary that provides terms and patterns for describing RDF datasets, and is intended as a bridge between the publishers and users of RDF data. VoiD descriptions can be used in many situations, ranging from data discovery to cataloging and archiving of datasets, but most importantly it helps users find the right data for their tasks.
VoiD covers four areas of metadata:
Deployment and discovery of VoID descriptions is discussed as well.
This document is one of the two core documents of VoID; the other is the VoID vocabulary definition [VOID-VOC].
This document is aimed at both dataset publishers (those involved in maintaining, administering and hosting datasets), and data users (those involved in finding, querying, crawling and indexing datasets).
Readers of this document should be familiar with the core concepts of RDF [RDF-PRIMER] and RDF Schema [RDFS]. Knowledge of the Turtle syntax [TURTLE] for RDF is required to read the examples. Some knowledge of widely-used vocabularies (Dublin Core [DC], Friend of a Friend [FOAF]) is also assumed.
All examples in this document are written in the Turtle RDF syntax [TURTLE]. Throughout the document, the following namespaces are used:
@prefix void: <http://rdfs.org/ns/void#> . @prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> . @prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#> . @prefix owl: <http://www.w3.org/2002/07/owl#> . @prefix xsd: <http://www.w3.org/2001/XMLSchema#> . @prefix dcterms: <http://purl.org/dc/terms/> . @prefix foaf: <http://xmlns.com/foaf/0.1/> . @prefix wv: <http://vocab.org/waiver/terms/norms> . @prefix sd: <http://www.w3.org/ns/sparql-service-description#> .
Furthermore, we assume that the empty prefix is bound to the base URL of the current file like this:
@prefix : <#> .
This allows us to quickly mint new identifiers in the local namespace: :MyDataset
, :DBpedia
and so on. Later sections of this specification provide more guidance on deploying VoID descriptions.
The fundamental concept of VoID is the dataset. A dataset is a set of RDF triples that are published, maintained or aggregated by a single provider. Unlike RDF graphs, which are purely mathematical constructs [RDF-CONCEPTS], the term dataset has a social dimension: we think of a dataset as a meaningful collection of triples, that deal with a certain topic, originate from a certain source or process, are hosted on a certain server, or are aggregated by a certain custodian. Also, typically a dataset is accessible on the Web, for example through resolvable HTTP URIs or through a SPARQL endpoint, and it contains sufficiently many triples that there is benefit in providing a concise summary.
Since most datasets describe a well-defined set of entities, datasets can also be seen as a set of descriptions of certain entities, which often share a common URI prefix (such as http://dbpedia.org/resource/
).
In VoID, a dataset is modelled as an instance of the void:Dataset
class. Such a void:Dataset
instance is a single RDF resource that represents the entire dataset, and thus allows us to easily make statements about the entire dataset and all its triples.
The relationship between a void:Dataset
instance and the concrete triples contained in the dataset is established through access information, such as the address of a SPARQL endpoint where the triples can be accessed.
The following example declares the resource :DBpedia
as a void:Dataset
:
:DBpedia a void:Dataset .
The resource is intended as a proxy for the well-known DBpedia dataset [DBPEDIA]. A good next step would be to make this unambiguously clear by adding general metadata and access metadata to the resource.
VoID also allows the description of RDF links between datasets. An RDF link is an RDF triple whose subject and object are described in different datasets.
A linkset is a collection of such RDF links between two datasets. It is a set of RDF triples where all subjects are in one dataset and all objects are in another dataset. RDF links often have the owl:sameAs
predicate, but any other property could occur as the predicate of RDF links as well.
In VoID, a linkset is modelled as an instance of the void:Linkset
class. void:Linkset
is a subclass of void:Dataset
.
The following example declares the resource :DBpedia_Geonames
as a void:Linkset
:
:DBpedia_Geonames a void:Linkset .
The resource is intended as a proxy for a set of triples that link resources in the DBpedia [DBPEDIA] and Geonames [GEONAMES] datasets. A good next step would be to make this clear by stating that these two datasets are the targets of the linkset.
Links are sometimes published as part of a larger dataset. For example, many of the resources described in the DBpedia dataset are linked via owl:sameAs
to other datasets. In other cases, linksets are handled as stand-alone sets of triples, independently from either of the two linked datasets. For example, link generation tools such as Silk [SILK] can discover new links between two existing datasets. Both cases—linksets published as part of a larger dataset, and linksets that are independent from the linked datasets—can be described in VoID.
Note: rdf:type
statements are not considered links for the purposes of VoID, even though subject and object typically reside on different domains. VoiD has a dedicated mechanism for listing the classes used in a dataset.
This section describes how to provide general metadata about a dataset or linkset. General metadata helps potential users of a dataset to decide whether the dataset is appropriate for their purposes. It includes information such as a title and description, the license of the dataset, and information about its subject.
Due to the inherently extensible design of RDF, any other property not listed here can of course also be used to describe a dataset.
Almost every dataset will have a homepage of some sort on the web, where further information about the dataset can be found. A link to the dataset's homepage can be provided with the foaf:homepage
property:
:DBpedia a void:Dataset; foaf:homepage <http://dbpedia.org/>; .
It is expected that the homepage linked to in fact talks about the dataset described.
As foaf:homepage
is an Inverse Functional Property ([OWL], Section 6.1), different descriptions of a dataset provided in different places on the Web can be automatically connected or “smushed” if they use the same homepage URI. To avoid inappropriate “smushing”, one should not use related pages that are not specifically about the dataset, such as the funding project's homepage or publishing organisation's homepage, as the value of foaf:homepage
.
Additional web pages with relevant information that can not be considered the homepage of the dataset can be linked with foaf:page
:
:DBpedia a void:Dataset; foaf:homepage <http://dbpedia.org/>; foaf:page <http://ckan.net/package/dbpedia>; foaf:page <http://dbpedia.org/Downloads>; .
The Dublin Core Metadata Terms [DC] contain a number of useful and recommended properties for providing basic metadata about a dataset.
| Term | Purpose |
|---|---|
dcterms:title |
The name of the dataset. |
dcterms:description |
A textual description of the dataset. |
dcterms:creator |
An entity, such as a person, organisation, or service, that is primarily responsible for creating the dataset. The creator should be described as an RDF resource, rather than just providing the name as a literal. |
dcterms:publisher |
An entity, such as a person, organisation, or service, that is responsible for making the dataset available. The publisher should be described as an RDF resource, rather than just providing the name as a literal. |
dcterms:contributor |
An entity, such as a person, organisation, or service, that is responsible for making contributions to the dataset. The contributor should be described as an RDF resource, rather than just providing the name as a literal. |
dcterms:source |
A related resource from which the dataset is derived. The source should be described as an RDF resource, rather than as a literal. |
dcterms:date |
A point or period of time associated with an event in the life-cycle of the resource. The value should be formatted and data-typed as an xsd:date . |
dcterms:created |
Date of creation of the dataset. The value should be formatted and data-typed as an xsd:date . |
dcterms:issued |
Date of formal issuance (e.g., publication) of the dataset. The value should be formatted and datatyped as an xsd:date . |
dcterms:modified |
Date on which the dataset was changed. The value should be formatted and datatyped as an xsd:date . |
The following example shows a description of DBpedia that uses many of the properties above. It also provides additional details about some of the resources mentioned in the Dublin Core metadata, in particular the contributing organizations:
:DBpedia a void:Dataset; dcterms:title "DBPedia"; dcterms:description "RDF data extracted from Wikipedia"; dcterms:contributor :FU_Berlin; dcterms:contributor :University_Leipzig; dcterms:contributor :OpenLink_Software; dcterms:contributor :DBpedia_community; dcterms:source <http://dbpedia.org/resource/Wikipedia>; dcterms:modified "2008-11-17"^^xsd:date; . :FU_Berlin a foaf:Organization; rdfs:label "Freie Universität Berlin"; foaf:homepage <http://www.fu-berlin.de/>; . # Similar descriptions of the other contributors go here
Potential users of a dataset may want to get in touch with the publisher or other contributors. Contact information can be attached to any of the entities that are given as the dcterms:publisher
, dcterms:creator
and dcterms:contributor
of a dataset. In particular, the foaf:mbox
property [FOAF] can be used to specify that entity's contact email address.
The following example shows how to provide a contact email address for the publisher of a dataset:
:ExampleDataset a void:Dataset; dcterms:publisher :Alice; . :Alice a foaf:Person; rdfs:label "Alice McExample"; foaf:mbox<EMAIL_ADDRESS>.
If the publisher were an organization, then typing it as foaf:Organization
would be appropriate.
Data without explicit license is a potential legal liability and leaves consumers unclear what the usage conditions are. Therefore, it is very important that publishers make explicit the terms under which the dataset can be used.
The dcterms:license
property should be used to to point to the license under which a dataset has been published. The URIs of some licenses designed specifically for data are:
http://www.opendatacommons.org/licenses/pddl/
http://www.opendatacommons.org/licenses/by/
http://www.opendatacommons.org/licenses/odbl/
http://creativecommons.org/publicdomain/zero/1.0/
The use of other licenses that are not designed specifically for data is discouraged because they may not have the intended legal effect when applied to data. Nevertheless, some other licenses are currently in common usage, including:
http://creativecommons.org/licenses/by-sa/3.0/
http://www.gnu.org/copyleft/fdl.html
While a publisher may want to facilitate reuse of their data with a very liberal rights statement, they may still wish to point to some community norms. Norms are non-binding conditions of use that publishers would like to encourage the users of their data to adopt. This can be done with the waiver:norms
property defined in the Waiver vocabulary [WAIVER].
A common community norm is ODC Attribution Sharealike. In brief, it asks that changes and updates to the dataset are made public too, that credit is given, that the source of the data is linked, that open formats are used, and that no DRM is applied:
http://www.opendatacommons.org/norms/odc-by-sa/
The following example states that the Example dataset is published under the terms of the Open Data Commons Public Domain Dedication and License, and that users are encouraged (but not legally bound) to follow the community norms mentioned above.
:Example a void:Dataset ; dcterms:license <http://www.opendatacommons.org/odc-public-domain-dedication-and-licence/>; wv:norms <http://www.opendatacommons.org/norms/odc-by-sa/>; wv:waiver """To the extent possible under law, The Example Organisation has waived all copyright and related or neighboring rights to The Example Dataset."""; .
Note: Licensing of datasets is a complex issue. Datasets are collections of facts rather than creative works, and different laws apply. Most licenses such as Creative Commons or the GPL are based on copyright and are designed to protect creative works, but not databases, and applying them to datasets might not have the desired legal result. Meanwhile, efforts such as Open Data Commons, Science Commons and Health Commons are developing dedicated licenses for data, and the OpenDOAR project provides tools allowing open-access digital repositories to create customised policies.
When someone wants to select a dataset, one of the fundamental questions is, what does the dataset actually offer? There are datasets such as DBpedia that cover quite a range of topics, whereas there are others that only talk about a certain domain (books, places, etc.).
In VoID, the dcterms:subject
property should be used to tag a dataset with a topic.
For the general case, we recommend the use of a DBpedia resource URI (http://dbpedia.org/resource/XXX
) to categorise a dataset, where XXX stands for the thing which best describes the main topic of what the dataset is about.
Two examples are given below. DBLP is a computer science bibliography database, and Geonames offers data about places. We define this in VoID:
:DBLP a void:Dataset; dcterms:subject <http://dbpedia.org/resource/Computer_science>; dcterms:subject <http://dbpedia.org/resource/Journal>; dcterms:subject <http://dbpedia.org/resource/Proceedings>; . :Geonames a void:Dataset; dcterms:subject <http://dbpedia.org/resource/Location>; .
DBpedia might not contain the concepts for describing some domain specific datasets. For example, there are no exact DBpedia resource URIs for “in situ hybridisation images” or “UniProt Genes”.
In such cases, datasets should be tagged with concept URIs that are widely adopted in the respective community. Concept URIs from a SKOS concept scheme [SKOS] are particularly appropriate. Using widely adopted domain-specific concepts ensures that not only the categorisation is precisely captured, but also that these datasets could be connected with other relevant data from their domains.
For example, we could define that:
:Bio2RDF a void:Dataset; dcterms:subject <http://purl.uniprot.org/core/Gene>; .
The property of void:feature
can be used for expressing certain technical features of a dataset, such as its supported RDF serialization formats. The domain of the property is void:Dataset
and its range is void:TechnicalFeature
. W3C provides a list of unique URIs [UUFFF] to describe file formats. Those that are relevant to RDF serialization format are listed in the following table.
| URI | Format |
|---|---|
http://www.w3.org/ns/formats/N3 |
Notation3 (N3): A readable RDF syntax: W3C Team Submission 14 January 2008 |
http://www.w3.org/ns/formats/N-Triples |
N-Triples (in RDF Test Cases: W3C Recommendation 10 February 2004) |
http://www.w3.org/ns/formats/RDF_XML |
RDF/XML Syntax Specification: W3C Recommendation 10 February 2004 |
http://www.w3.org/ns/formats/RDFa |
RDFa in XHTML: Syntax and Processing: W3C Recommendation 14 October 2008 |
http://www.w3.org/ns/formats/Turtle |
Turtle - Terse RDF Triple Language: W3C Team Submission 14 January 2008 |
For example, using the W3C URIs together with void:feature
we can express that “a dataset is available as RDF/XML”:
:DBpedia a void:Dataset; void:feature <http://www.w3.org/ns/formats/RDF_XML>; .
These W3C URIs are instances of class http://www.w3.org/ns/formats/vocab-data/Format
, which is a sub-class of void:TechnicalFeature
. If users need to describe, for example, other media types besides those provided by W3C or HTTP features such as content negotiation or ETag headers, they should create the URIs under their own namespace or reuse existing URIs and define them as an instance of void:TechnicalFeature
. For example, the following code shows how one could define a feature :HTTPCachingETags
as an instance of void:TechnicalFeature
.
:HTTPCachingETags a void:TechnicalFeature; rdfs:label "HTTP ETag support"; rdfs:comment "the dataset supports HTTP caching using ETags"; rdfs:seeAlso <http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#>; .
Datasets in VoID are defined as sets of RDF triples. But the actual RDF triples are not part of the VoID description. Instead, access metadata is used to describe methods of accessing the actual RDF triples.
If the entities described in a dataset are identified by HTTP URIs, then it is a reasonable assumption that resolving such a URI will return an RDF description of the entity.
A SPARQL endpoint that provides access to a dataset via the SPARQL protocol can be announced using void:sparqlEndpoint
:
:DBpedia a void:Dataset; void:sparqlEndpoint <http://dbpedia.org/sparql>; .
This states that the default graph of the SPARQL endpoint contains the triples in the DBpedia dataset.
VoID descriptions can be deployed as part of a SPARQL Service Description. This also allows the expression of further information about the features and capabilites of the SPARQL endpoint, as described in the SPARQL 1.1 Service Description [SPARQL-SD] specification.
Note: In some SPARQL endpoints, named graphs are used to partition the data. Currently VoID doesn't provide a dedicated way of stating that a dataset is contained in a specific named graph. This kind of information can be provided in a SPARQL Service Description, as described below.
If an RDF dump of the dataset is available, then its location can be announced using void:dataDump
. If the dataset is split into multiple dumps, then several values of this property can be provided.
The format of such dumps is not prescribed, but clients should expect dumps to be in one of the usual RDF serializations (RDF/XML, N-Triples, Turtle), and possibly compressed using GZip or other compression algorithms.
The following example states that the complete :NYTimes
dataset is available as a set of four RDF files.
:NYTimes a void:Dataset; void:dataDump <http://data.nytimes.com/people.rdf>; void:dataDump <http://data.nytimes.com/organizations.rdf>; void:dataDump <http://data.nytimes.com/locations.rdf>; void:dataDump <http://data.nytimes.com/descriptors.rdf>; .
Note: The void:dataDump
property should not be used for linking to a download web page. It should only be used for linking directly to dump files. This is to ensure that the link can be used by automated spiders that cannot find their way through an HTML page. If a publisher desires to provide a link to a download page as well, then they should use the foaf:page
property instead.
Many datasets are structured in a tree-like fashion, with one or a few natural “top concepts” or “entry points”, and all other entities reachable from these root resources in a small number of steps.
One or more such root resources can be named using the void:rootResource
property. Naming a resource as a root resource implies:
Root resources make good entry points for crawling an RDF dataset.
This property is similar to void:exampleResource
. While void:exampleResource
names particularly representative or typical resources in the dataset, void:rootResource
names particularly important or central resources that make good entry points for navigating the dataset.
Besides the SPARQL protocol, a simple URI lookup protocol for accessing a dataset can also be described using VoID. Such a protocol could take the following steps:
Note: The HTTP request should be performed with an HTTP Accept header that indicates the formats supported by the requesting client, e.g. “Accept: application/rdf+xml
” for a client that only supports RDF/XML.
The following example shows how the Sindice API [SINDICE-API] could be described as a VoID dataset with a URI lookup endpoint:
:Sindice a void:Dataset ; void:uriLookupEndpoint <http://api.sindice.com/v2/search?qt=term&q=> .
Some datasets offer a free text search capability. Dataset publishers may create an OpenSearch Description Document [OPENSEARCH] that describes their text search service. This can be linked to a Dataset resource using the void:openSearchDescription
property:
:Sindice a void:Dataset; void:openSearchDescription <http://www.sindice.com/opensearch.xml>.
The RDF data model is highly flexible and places almost no constraints on the structure of datasets. This flexibility has many advantages, but also makes interacting with an unfamiliar dataset harder. Structural metdata provides high-level information about the schema and internal structure of a dataset and can be helpful when exploring or querying datasets. This includes information such as the vocabularies used in the dataset, statistics about the size of the dataset, and examples of typical resources in the dataset.
For documentation purposes, it can be helpful to name some representative example entites for a dataset. Looking up these entities allows users to quickly get an impression of the kind of data that is present in a dataset. The void:exampleResource
property names one or more such examples:
:DBpedia a void:Dataset; void:exampleResource <http://dbpedia.org/resource/Berlin> ; void:exampleResource <http://dbpedia.org/resource/Physics> ; void:exampleResource <http://dbpedia.org/resource/Ludwig_van_Beethoven> ; .
Note: Datasets that are published as linked data with resolvable URIs often have two distinct URIs for an entity and for the RDF document describing the entity [COOL]. True entity URIs should be preferred as void:exampleResource
s.
Example resources can also be given for linksets. The resource should be either the subject or the object of a representative link from the set.
If the linkset is a void:subset
(see Section 4.4) of another dataset D, that is, the linkset is contained in D, then a resource described in D should be preferred as the example for the linkset. For example, if the linkset :DBpedia_Geonames
is a subset of DBpedia, and we choose
<http://dbpedia.org/resource/Berlin> owl:sameAs <http://sws.geonames.org/2950159/>.
as a representative link, then we should use the resource from the DBpedia side as the void:exampleResource
for the linkset, because users can look up the example in DBpedia, but not necessarily in Geonames.
Often, the entities described in a dataset share URIs of a common form. For example, all DBpedia entity URIs start with http://dbpedia.org/resource/
.
The void:uriSpace
property can be used to state that all entity URIs in a dataset start with a given string. In other words, they share a common “URI namespace”.
:DBpedia a void:Dataset; void:uriSpace "http://dbpedia.org/resource/"; .
Note: The value of void:uriSpace is an RDF literal. That is, in Turtle it is written like "http://dbpedia.org/resource/"
, not <http://dbpedia.org/resource/>
.
In cases where a simple string prefix match is insufficient, the void:uriRegexPattern
property can be used. It expresses a regular expression pattern that matches the URIs of the dataset's entities.
The pattern should use the same regular expression syntax as SPARQL, which uses the syntax definition of XML Schema 2: Regular Expressions ([XSD], Appendix F). The regular expression must match somewhere in the URI. It is a good practice to anchor the regular expression with a ^
in the beginning, and to escape dots with a backslash.
A simple example of using void:uriRegexPattern
, equivalent to the void:uriSpace
example above:
:DBpedia a void:Dataset; void:uriRegexPattern "^http://dbpedia\\.org/resource/"; .
Note: In the Turtle syntax, any backslashes in literals have to be escaped with another backslash. This is why the example above contains double backslashes. In RDF/XML, the same literal would be written as:
<void:uriRegexPattern>^http://dbpedia\.org/resource/</void:uriRegexPattern>
A more complex example follows:
:DBpediaTurtleFiles a void:Dataset; void:uriRegexPattern "^http://dbpedia\\.org/(.+)\\.ttl$"; void:feature <http://www.w3.org/ns/formats/Turtle>; .
This defines a dataset (presumably a subset of :DBpedia
) that contains only URIs ending in .ttl
, and states that they have Turtle representations, using void:feature
.
Note: One can use the REGEX
filter function of SPARQL to check whether a URI matches a void:uriRegexPattern
. The SPARQL standard does not contain a function for comparing string prefixes, so the same cannot be safely done with void:uriSpace
(although some SPARQL implementations support such string comparisons via extension functions). This is one advantage of void:uriRegexPattern
. To obtain an equivalent regular expression from a void:uriSpace
URI, prepend it with the “^
” character and escape any of the characters “.()[]+*?$
” with a backslash.
Every RDF dataset uses one or more RDFS vocabularies or OWL ontologies. The vocabulary provides the terms (classes and properties) for expressing the data. The void:vocabulary
property can be used to list vocabularies used in a dataset.
Every value of void:vocabulary
must be a URI that identifies a vocabulary or ontology that is used in the dataset. These URIs can be found as follows:
The following table illustrates this:
| Vocabulary | Example term URI | Vocabulary URI |
|---|---|---|
| DC terms | http://purl.org/dc/terms/title |
http://purl.org/dc/terms/ |
| SIOC | http://rdfs.org/sioc/ns#Post |
http://rdfs.org/sioc/ns |
It is not necessary to list all vocabularies. Typically, only the most important vocabularies will be listed, especially those that can be useful in querying the dataset.
The following example states that the :LiveJournal
dataset uses the
FOAF vocabulary [FOAF].
:LiveJournal a void:Dataset; void:vocabulary <http://xmlns.com/foaf/0.1/>; .
The void:vocabulary
property can only be used for entire vocabularies. It can not be used to express that individual classes and properties occur in a dataset. For this purpose, class partitions and property partitions can be used.
The void:subset
property can be used to provide descriptions of parts of a dataset. A part of a dataset is itself a void:Dataset
, and any of the annotations for datasets listed in this guide can be applied to the subset. Reasons for subdividing a dataset might include:
dcterms:source
)dcterms:date
)void:sparqlEndpoint
)dcterms:subject
)void:dataDump
)The last example is expressed in the following snippet, which expresses the fact that parts of the DBpedia dataset can be downloaded as separate RDF dumps:
:DBpedia a void:Dataset; void:subset :DBpedia_shortabstracts; void:subset :DBpedia_infoboxes; . :DBpedia_shortabstracts a void:Dataset; dcterms:title "DBpedia Short Abstracts"; dcterms:description "Short Abstracts (max. 500 chars long) of Wikipedia Articles"; void:dataDump <http://downloads.dbpedia.org/3.3/en/shortabstract_en.nt.bz2>; . :DBpedia_infoboxes a void:Dataset; dcterms:title "DBpedia Infoboxes"; dcterms:description "Information that has been extracted from Wikipedia infoboxes."; void:dataDump <http://downloads.dbpedia.org/3.3/en/infobox_en.nt.bz2>; .
Making statements about a subset emphasizes that the statements apply only to a part of the dataset, and not the whole dataset. Note that the void:subset
mechanism can also be used to describe aggregated datasets, in addition to partitioned datasets. The aggregation of two datasets :DS_A
and :DS_B
can be described like this:
:Aggregate_DS a void:Dataset; dcterms:title "Aggregate Dataset"; dcterms:description "An aggregate of the A and B datasets."; void:sparqlEndpoint <http://example.org/sparql>; void:subset :DS_A; void:subset :DS_B; .
Class- and property-based partitioning offers a way of talking about particular classes and properties in a dataset.
Note that void:classPartition
and void:propertyPartition
are subproperties of void:subset
. This means that the partition is itself a dataset.
A dataset that is the void:classPartition
of another dataset must have exactly one void:class
property. The partition contains all triples that describe entities that have this class as their rdf:type
.
A class-based partition with rdfs:Resource
as its void:class
is defined to also contain all resources that have no explicit rdf:type
statement.
A dataset that is the void:propertyPartition
of another dataset must have exactly one void:property
property. The partition contains all triples that have this property as their predicate.
A partition without any statistical properties is thought to contain at least one triple. Hence, the following example asserts that the classes foaf:Person
and foaf:Organization
and the properties foaf:name
, foaf:member
, foaf:homepage
and rdf:type
are used in the dataset :MyDataset
, without any assertion about the number of instances:
:MyDataset a void:Dataset; void:classPartition [ void:class foaf:Person; ]; void:classPartition [ void:class foaf:Organization; ]; void:propertyPartition [ void:property foaf:name; ]; void:propertyPartition [ void:property foaf:member; ]; void:propertyPartition [ void:property foaf:homepage; ]; void:propertyPartition [ void:property rdf:type; ]; .
VoID provides a number of properties for expressing numeric statistics about a dataset, such as the number of RDF triples it contains, or the number of entities it describes.
Note: A previous version of VoID defined a different approach to statistics, based on the Statistical Core Vocabulary. It was found to have several disadvantages. Statistics would be verbose, and querying them with SPARQL was difficult. A description of the SCOVO-based approach can be found in archived older versions of the VoID Guide ([VOID-GUIDE-1], Section 3). We discourage its further use.
As a general rule, statistics in VoID can always be provided as approximate numbers.
VoID defines the following properties for expressing different statistical characteristics of datasets:
| Property | Purpose |
|---|---|
void:triples |
The total number of triples contained in the dataset. |
void:entities |
The total number of entities that are described in the dataset. To be an entity in a dataset, a resource must have a URI, and the URI must match the dataset's void:uriRegexPattern , if any. Authors of VoID files may impose arbitrary additional requirements, for example, they may consider any foaf:Document resources as not being entities. |
void:classes |
The total number of distinct classes in the dataset. In other words, the number of distinct class URIs occuring as objects of rdf:type triples in the dataset. |
void:properties |
The total number of distinct properties in the dataset. In other words, the number of distinct property URIs that occur in the predicate position of triples in the dataset. |
void:distinctSubjects |
The total number of distinct subjects in the dataset. In other words, the number of distinct URIs or blank nodes that occur in the subject position of triples in the dataset. |
void:distinctObjects |
The total number of distinct objects in the dataset. In other words, the number of distinct URIs, blank nodes, or literals that occur in the object position of triples in the dataset. |
void:documents |
If the dataset is published as a set of individual documents, such as RDF/XML documents or RDFa-annotated web pages, then this property indicates the total number of such documents. Non-RDF documents, such as web pages in HTML or images, are usually not included in this count. This property is intended for datasets where the total number of triples or entities is hard to determine. void:triples or void:entities should be preferred where practical. |
The following example states the approximate number of triples and entities in the DBpedia dataset:
:DBpedia a void:Dataset; void:triples<PHONE_NUMBER>; void:entities 3400000; .
Since void:Linkset
is a subclass of void:Dataset
, statistics about the triples in a linkset can be provided in the same way as for datasets. Most importantly, the number of links in a linkset can be recorded with void:triples
. The following example states that the DBpedia-to-DBLP linkset contains approximately 10,000 owl:sameAs
links:
:DBpedia2DBLP a void:Linkset; void:target :DBpedia; void:target :DBLP; void:linkPredicate owl:sameAs; void:triples 10000; .
Class- and property-based partitions can be used to provide statistics such as the number of instances of a given class and the number of triples that have a certain predicate. Partitions can be described with VoID's usual statistical features, such as void:entities
and void:triples
.
The following example shows how this approach is used to state that the DBpedia dataset contains 312,000 entities of class foaf:Person
, and 312,000 triples that have the foaf:name
predicate:
:DBpedia a void:Dataset; void:classPartition [ void:class foaf:Person; void:entities 312000; ]; void:propertyPartition [ void:property foaf:name; void:triples 312000; ]; .
A class-based partition for the foaf:Person
class is defined, and it is stated to contain 312,000 entities. Because a class-based partition contains only the subset that describes entities of a single class (foaf:Person
in this case), we can conclude that the DBpedia dataset describes 312,000 people. Statistics about further classes could be given in the same way.
Note: Many dataset statistics can be calculated automatically by running SPARQL queries over the dataset. Some informative examples for SPARQL queries that compute statistics are given in the VoID wiki.
The void:Linkset
class is a subclass of void:Dataset
. All patterns for describing datasets can equally be used for linksets. There are however a number of specific properties for describing linksets.
The structure of a typical linkset description is illustrated below: It expresses that the DBpedia dataset contains a subset of owl:sameAs
links that connect resources in DBpedia to resources in Geonames.
Linksets are defined as collections of RDF triples where subjects and objects of the triples are described in different datasets. The void:target
property is used to name the two datasets. Every linkset must have exactly two distinct void:target
s.
The following example states that the :DBpedia_Geonames
linkset connects the :DBpedia
and :Geonames
datasets. Presumably, the VoID file would contain additional information about those two resources:
:DBpedia_Geonames a void:Linkset; void:target :DBpedia; void:target :Geonames; .
void:target
has subproperties void:subjectsTarget
and void:objectsTarget
. These can be used to state the subject-object direction of the links explicitly: The subjects of all link triples are in the dataset named by void:subjectsTarget
, and the objects in void:objectsTarget
.
A linkset may not have more than one void:subjectsTarget
. A linkset may not have more than one void:objectsTarget
.
Note: There are two different notions of “directionality” for RDF links:
The void:subjectsTarget
and void:objectsTarget
properties express the first notion, while not stating anything about containment of the links. The second notion is expressed by making the linkset a void:subset
of the respective target datasets.
Especially when referring to owl:sameAs
links, usually the second notion is intended. The property is symmetric, so their subjects and objects are exchangeable. The question is usually which publisher made the links available as part of their dataset.
To state that a linkset is a part of a larger dataset, the void:subset
property should be used:
:DBpedia_Geonames a void:Linkset; void:target :DBpedia; void:target :Geonames; void:subset :DBpedia; void:triples 252000; .
The example expresses that the DBpedia dataset contains a linkset of 252,000 links to Geonames.
The property void:linkPredicate
can be used to specify the type of links that connect two datasets. In other words, it names the RDF property in the predicate position of the link triples.
The following example uses void:linkPredicate
to state that the DBpedia and Geonames datasets are linked by triples that have the owl:sameAs
predicate:
:DBpedia_Geonames a void:Linkset; void:target :DBpedia; void:target :Geonames; void:linkPredicate owl:sameAs; .
A single void:Linkset should never have more than one value for void:linkPredicate
. If two datasets are connected by links of multiple RDF predicates, a separate void:Linkset
should be created for each type of link. For example, if datasets D1 and D2 are connected by two different types of links, through predicates p1 and p2:
:D1 a void:Dataset . :D2 a void:Dataset . :L1 a void:Linkset; void:linkPredicate :p1; void:target :D1; void:target :D2; . :L2 a void:Linkset; void:linkPredicate :p2; void:target :D1; void:target :D2; .
The VoID classes and properties are designed to be flexible and can be used in many different contexts. Some typical deployment scenarios for VoID and deployment-related considerations will be discussed in this section.
An instance of void:Dataset
stands as a proxy for an entire set of RDF triples. As always with RDF, an important question is what URI to choose for this dataset resource.
The use of blank nodes for void:Dataset
and void:Linkset
instances is generally discouraged, because blank nodes do not provide identifiers for linking to a resource. However, if the dataset resource is not of particular importance, and if the creation of stable URIs would be difficult, then a blank node can be acceptable, for example when subsets and partitions are defined solely for the purpose of expressing statistics.
When referring to a dataset published by another party (for example as a linkset target, or in a store that aggregates multiple other datasets), it is good practice to check whether the original publisher of the dataset has provided a VoID description (see the Discovery section on methods for discovering VoID descriptions), and use the URI assigned to the dataset there. If no URI has been provided by the original publisher, then one should mint a new URI in one's own namespace.
When one doesn't use a URI provided by the original data provider, then one should include a link to the homepage of the dataset to allow “smushing” based on the foaf:homepage
Inverse Functional Property.
Publishers are encouraged to provide descriptions of their datasets by publishing a VoID file on the web along with the dataset.
Popular options for publishing a VoID description alongside a dataset include:
void.ttl
in the root directory of the site, with a local “hash URI” for the dataset, yielding a dataset URI such as http://example.com/void.ttl#MyDataset
.http://example.com/
, as the dataset URI, and serving both HTML and an RDF format via content negotiation from that URI (see Cool URIs for the Semantic Web [COOL] for a more detailed description of this publishing approach).http://example.com/#MyDataset
VoID authors are encouraged to provide metadata for their VoID files. This can be done by adding a document metadata block to the VoID file. A typical document metadata block will contain:
void:DatasetDescription
.foaf:topic
or foaf:primaryTopic
statements that relate the VoID file to the dataset(s) described therein. If the VoID file describes a single dataset, then foaf:primaryTopic
should be used. If the file describes several datasets of equal importance, then foaf:topic
should be used.An example metadata block is shown below. Note the use of an empty-string relative URI (<>) as a syntactic shortcut. In Turtle and RDF/XML, the empty string URI stands for the URI of the document that contains the statements.
<> a void:DatasetDescription; dcterms:title "A VoID Description of the DBpedia Dataset"; dcterms:creator <http://richard.cyganiak.de/foaf.rdf#cygri>; foaf:primaryTopic :DBpedia; .
Note:
In cases where multiple different void:Dataset
s are published on the same website, the easiest option is usually to create a single void:DatasetDescription
document that describes all of them.
RDF datasets are often published on the web as many individual RDF documents. A common deployment pattern is to provide one description document for each resource in the dataset. On RDFa-enabled websites, each web page becomes an RDF document.
Providing metadata about the entire dataset in such a scenario should not be done by including VoID details in every document. Rather, a single VoID description of the entire dataset should be published, and individual documents should point to this description via backlinks.
A VoID backlink is a triple that points from an RDF document URI to a void:Dataset
URI using the void:inDataset
property:
<http://dbpedia.org/data/Berlin> void:inDataset :DBpedia .
Such a triple asserts that the triples serialised in the document are part of the dataset. Consequently, metadata of the dataset such as provenance and licensing information should be understood as applying to the data in the document.
One should not specify multiple void:inDataset
for the same document. Rather, we encourage to create a new void:Dataset that contains both as a subset, and link to that. Then, you can explicitly add metadata, like licenses, to the joint dataset.
Note: Older versions of VoID suggested to use dcterms:isPartOf
instead of void:inDataset
. As dcterms:isPartOf
is used for other purposes as well, we introduced a dedicated property in the VoID namespace.
VoID can be used to provide self-describing metadata in RDF dumps.
To describe an RDF dump, one should not use the dump's download URL as a void:Dataset
and attach metadata to it.
Instead, one should use a different URI for the void:Dataset
, following the good practices for choosing dataset URIs. Metadata statements should then be made about that URI. The void:dataDump
property should be used to relate the dataset URI to the download URI of the RDF dump.
The W3C SPARQL 1.1 Service Description [SPARQL-SD] specification provides a rich vocabulary for describing a SPARQL endpoint's capabilities and features, as well as a discovery mechanism for such SPARQL service descriptions. VoID can be used in SPARQL service descriptions to provide additional information about the data available in a store.
The SPARQL Service Description vocabulary defines two classes that can be aligned with VoID:
sd:Dataset
represents a SPARQL dataset ([SPARQL], Section 8), that is, a set of zero or more named graphs plus an optional default graph. Note that sd:Dataset
has a narrower definition than void:Dataset
: Any collection of triples can be a void:Dataset
, while sd:Dataset
also requires that the triples are associated with the default graph or named graphs.sd:Graph
represents an RDF graph within an sd:Dataset
, either the default graph or one of the named graphs.void:Dataset
is a superclass of sd:Dataset
and of sd:Graph
. Therefore, any instance of these classes can be described just like any other VoID dataset.
The following fictional example describes a SPARQL endpoint that provides access to a mirror of DBpedia and Geonames in distinct named graphs, as well as to the service description itself in the default graph:
<#service> a sd:Service; sd:url <http://example.org/geopedia/sparql>; sd:defaultDatasetDescription [ a sd:Dataset; dcterms:title "GeoPedia"; dcterms:description "A mirror of DBpedia and Geonames"; void:triples<PHONE_NUMBER>; sd:defaultGraph [ a sd:Graph, void:Dataset; dcterms:title "GeoPedia SPARQL Endpoint Description"; dcterms:description "Contains a copy of this SD+VoID file!"; void:triples 100; ]; sd:namedGraph [ sd:name <http://dbpedia.org/>; sd:graph [ a sd:Graph, void:Dataset; dcterms:title "DBpedia"; foaf:homepage <http://dbpedia.org/>; void:triples<PHONE_NUMBER>; ]; ]; sd:namedGraph [ sd:name <http://geonames.org/>; sd:graph [ a sd:Graph, void:Dataset; dcterms:title "Geonames"; foaf:homepage <http://www.geonames.org/ontology/>; void:triples 100000000; ]; ]; ]; .
This section describes approaches for discovering the VoID description of a dataset given the URI of an entity described in a dataset.
Note: a previous version of VoID had a discovery mechanism based on robots.txt
and Semantic Sitemaps, which was deprecated because it was not widely adopted.
For datasets that are published as a collection of RDF documents in the linked data style, the preferred mechanism of discovering an associated VoID description is the void:inDataset
back-link mechanism. Clients should look for a void:inDataset
triple that links the RDF document to the dataset:
<document.rdf> void:inDataset <void.ttl#MyDataset>.
The RFC 5758 [RFC5758] defines a mechanism for reserving 'well-known' URIs on any Web server.
The URI /.well-known/void
on any Web server is registered by this specification for a VoID description of any datasets hosted on that server. For example, on the host www.example.com
, this URI would be http://www.example.com/.well-known/void
.
This URI may be an HTTP redirect to the location of the actual VoID file. The most appropriate HTTP redirect code is 302. Clients accessing this well-known URI MUST handle HTTP redirects.
The VoID file accessible via the well-known URI should contain descriptions of all RDF datasets hosted on the server. This includes any datasets that have resolvable URIs, a SPARQL endpoint, a data dump, or any other access mechanism (see Section 3, Access metadata) whose URI is on the server's hostname.
Any VoID file accessible via the well-known URI should follow the guidelines set out in Section 6.2, Publishing a voiD file alongside a dataset.
This document defines the “.well-known” URI void
using the registration procedure and template from Section 5.1 of [RFC5758] as follows:
URI suffix: void Change controller: W3C Specification document(s): This document.
The following tables give a quick overview of the terms defined in the VoID vocabulary. These tables are not normative; the normative definition of these terms is the VoID vocabulary document [VOID-VOC].
| VoID Term | Description | Details |
|---|---|---|
void:Dataset |
A set of RDF triples that are published, maintained or aggregated by a single provider. | Section 1.3 |
void:DatasetDescription |
A web resource whose foaf:primaryTopic or foaf:topic s include void:Dataset s. |
Section 6.2 |
void:Linkset |
A collection of RDF links between two void:Dataset s. |
Section 1.4 |
void:TechnicalFeature |
A technical feature of a void:Dataset , such as a supported RDF serialization format. |
Section 2.5 |
| VoID Term | Description | Details |
|---|---|---|
void:class |
The rdfs:Class that is the rdf:type of all entities in a class-based partition. |
Section 4.5 |
void:classes |
The total number of distinct classes in a void:Dataset . |
Section 4.6 |
void:classPartition |
A subset of a void:Dataset that contains only the entities of a certain rdfs:Class . |
Section 4.5 |
void:dataDump |
An RDF dump, partial or complete, of a void:Dataset . |
Section 3.3 |
void:distinctObjects |
The total number of distinct objects in a void:Dataset . |
Section 4.6 |
void:distinctSubjects |
The total number of distinct subjects in a void:Dataset . |
Section 4.6 |
void:documents |
The total number of documents, for void:Dataset s that are published as a set of individual RDF documents. |
Section 4.6 |
void:entities |
The total number of entities that are described in a void:Dataset . |
Section 4.6 |
void:exampleResource |
An example entity that is representative for the entities described in a void:Dataset . |
Section 4.1 |
void:feature |
A void:TechnicalFeature supported by a void:Datset . |
Section 2.5 |
void:inDataset |
Points to the void:Dataset that a document is a part of. |
Section 6.3 |
void:linkPredicate |
Specifies the RDF property of the triples in a void:Linkset . |
Section 5.3 |
void:objectsTarget |
The void:Dataset that contains the resources in the object position of a void:Linkset 's triples. |
Section 5.1 |
void:openSearchDescription |
An OpenSearch description document for a free-text search service over a void:Dataset . |
Section 3.6 |
void:properties |
The total number of distinct properties in a void:Dataset . |
Section 4.6 |
void:property |
The rdf:Property that is the predicate of all triples in a property-based partition. |
Section 4.5 |
void:propertyPartition |
A subset of a void:Dataset that contains only the triples of a certain rdf:Property . |
Section 4.5 |
void:rootResource |
A top concept or entry point for a void:Dataset that is structured in a tree-like fashion. |
Section 3.4 |
void:sparqlEndpoint |
A SPARQL protocol endpoint that allows SPARQL query access to a void:Dataset . |
Section 3.2 |
void:subjectsTarget |
The void:Dataset that contains the resources in the subject position of this void:Linkset 's triples. |
Section 5.1 |
void:subset |
A void:Dataset that is part of another void:Dataset . |
Section 4.4 |
void:target |
One of the two void:Dataset s connected by this void:Linkset . |
Section 5.1 |
void:triples |
The total number of triples contained in a void:Dataset . |
Section 4.6 |
void:uriLookupEndpoint |
A protocol endpoint for simple URI lookups for a void:Dataset . |
Section 3.5 |
void:uriRegexPattern |
A regular expression that matches the URIs of a void:Dataset 's entities. |
Section 4.2 |
void:uriSpace |
A URI that is a common string prefix of all the entity URIs in a void:Datset . |
Section 4.2 |
void:vocabulary |
A vocabulary or owl:Ontology whose classes or properties are used in a void:Dataset . |
Section 4.3 |
Our thanks go out to some chaps who influenced the design of VoID, provided use cases and ensured that we would never get bored too quickly. These people were (alphabetically): Dan Brickley, Li Ding, Orri Erling, Hugh Glaser, Olaf Hartig, Tom Heath, Toby Inkster, Ian Millard, Marc-Alexandre Nolin, Yves Raimond, Yrjänä Rankka, Francois Scharffe, Giovanni Tummarello, William Waites, Stuart Williams.
The work has partly been supported by the following projects:


Direct Debit API
Purchases
Submit Purchase
With Payment Token
Without Payment Token
For ACH Bank Account
For EFT Bank Account
StandaloneCredits
Submit StandaloneCredits
With Payment Token
Without Payment Token
For ACH Bank Account
For EFT Bank Account


Zydus Cadila gets tentative USFDA approval to market arthritis drug
The tablets will be manufactured at the group's manufacturing facility at SEZ, Ahmedabad, Zydus Cadila said.
by Press Trust of IndiaDrug firm Zydus Cadila on Saturday said it has received a tentative approval from the US health regulator to market generic Apremilast tablets.
The company has received the tentative approval from the United States Food and Drug Administration (USFDA) to market the tablets in the strengths of 10 mg, 20 mg, and 30 mg, Zydus Cadila said in a filing to BSE.
This medication is used to treat psoriatic arthritis and moderate to severe plaque psoriasis. It is also used to treat mouth sores in people who have Behcet's disease, it added.
The tablets will be manufactured at the group's manufacturing facility at SEZ, Ahmedabad, Zydus Cadila said.
The group now has 276 approvals and has so far filed over 360 ANDAs since the commencement of its filing process, it added.


Bio
Hi, my name is Tianyi Ma. I was born and raised in the northeast part of China and moved to Seattle in 2006. I lived in the Pacific NW for more than 10 years and loved it.
Thank you for stopping by! I created this page to let people like you to know more about me. At the same time, I can practice the skills that I have learned from the Code Fellows as well.
Hi, my name is Tianyi Ma. I was born and raised in the northeast part of China and moved to Seattle in 2006. I lived in the Pacific NW for more than 10 years and loved it.


I didn't take any drugs the day before this so I wouldn't have any chemical interference. I have ingested/smoked/insuffalated many psychedelics including 2C-I, 2C-E, MDMA, MDA, Salvia, 5-meo-dmt, Psilocin, mescaline, LSD, and many others. I have had one other attempt at Morning Glory's but i got the wrong type so they made me even sicker.
About the seeds. The seeds were from a large online vendor. They were untreated and 100% viable to grow. I had 305 seeds total. I ingested them on a half full stomach. I ingested them slowly to ease any of the nasuea that i might have experienced (never did feel nasuea, just a clean body high:))
After ingesting seeds I took a hit of salvia. 20 X extract, very nice hit. All i really remember about it was a spot being opened up in the room i was in. Like a window of clarity. I distinctly remember thinking how beautifal that spot was. I was calling that spot the sun for some reason. I think it had something to do with my reading about how the morning glory seeds were supposed to be the semen of the sun god in aztec culture. But during my trip that spot was the sun, my surrondings slowly became the rainforest. but it was over before it could begin. I felt a need to ponder this trip so I went to lay down and think.
1 hour later I awake to feeling a slight mood boost and sensing a brightness of something beginnning. I woke up right in time for the come-up. My enviroment wasn't to freindly for someone who was on a new psychedelic. I decided a bike ride wouldn't be to difficult at this point in my trip. I took another hit of Salvia before I left and nestled myself into the arms of the sun-god to observe my surrondings through his eyes. It was really mellow and relaxing.
When i came out of it I decided it was time to go so I said my farewells and grabbed my bike. This bike ride was one of pure beauty, I live in Alaska so the quality of the nature is really good. I rode a trail the entire 4.5 miles home. It was relaxing and gave me time to think about the effects of this wonderful seed. I felt as though i had known this feeling however slightly more harsh. I had reached a point of personal bliss i had never felt with acid. or any other chemical for that matter, aside from mescaline and psilocin. I loved the nature around me in a way i have never before. I felt the tree's around me, my immediate surrondings shaped my mood. I was nearly home. I pulled off the trail and through the park when low and behold there was two cops. I felt a little rush of paranoia until i noticed them taking a man into custody. Thank God i probably would have gotten mugged for my bike.
I made my way down the road until i got to my street. I arrived at home in less than half an hour. Not bad for tripping. The rest of my night was consumed with staring at the ceiling and watching it morph from Amoebas to chemical structures of many of my favorite molecules to a sea of flowing cottage cheese. When i went to bed i had many closed eye visuals, the most memorable was when i saw myself standing at the mirror and then it went to through my eyes vision and my reflection turned into a dinosaur and i turned into a dinosuar and started marching around the jungle. It was the best closed eye imagery i have ever had.
By far morning glory seeds were better than any acid i have found in alaska, So i think i will work more with them, possibly in combonation with mescaline. However i have felt a little drifty ever since, like my brains a little foggy.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


What happens if I have 3 or more cards in my hand when I flip Sunstorm to alt mode?
Nothing.
How does Sunstorm’s ability work with Actions or Upgrades that raise his attack?
Sunstorm’s ability sets his base attack value, what you’d see printed on the card if it didn’t change.
From there, Actions and Upgrades can raise that value. For example, if you have 3 cards in hand, his
base attack would be 3. If he then got a Weapon that gave him +2 attack, his attack would be 5. This
wouldn’t change the number of cards in your hand.


{% extends "layout.html" %} {% block page_title %} Home Office - Visa and Immigration {% endblock %} {% block content %} {% include "includes/phase_banner_alpha.html" %} {% include "includes/outgoing-header.html" %} Find an applicant Unique application number (UAN) Missing sponsor name - update in CID {% endblock %}


| Build Log |
|
| Command Lines |
Creating temporary file "c:\ActiveX\XMLSign\SigWinImage\Debug\RSP000025.rsp" with contents [ /Od /D "WIN32" /D "_WINDOWS" /D "_DEBUG" /D "_USRDLL" /D "_ATL_ATTRIBUTES" /D "_WINDLL" /D "_ATL_STATIC_REGISTRY" /D "_MBCS" /Gm /EHsc /RTC1 /MDd /Yu"stdafx.h" /Fp"Debug/SigWinImage.pch" /Fo"Debug/" /Fd"Debug/vc70.pdb" /W3 /c /Wp64 /ZI /TP .\SigMouseImage.cpp .\CaptureImage.cpp ] Creating command line "cl.exe @c:\ActiveX\XMLSign\SigWinImage\Debug\RSP000025.rsp /nologo" |
| Output Window |
Compiling... SigMouseImage.cpp c1xx : fatal error C1001: INTERNAL COMPILER ERROR (compiler file 'Debug/SigWinImage.pch', line 1) Please choose the Technical Support command on the Visual C++ Help menu, or open the Technical Support help file for more information CaptureImage.cpp c1xx : fatal error C1060: compiler is out of heap space c1xx : fatal error C1063: INTERNAL COMPILER ERROR Please choose the Technical Support command on the Visual C++ Help menu, or open the Technical Support help file for more information Generating Code... |
| Results |
Build log was saved at "file://c:\ActiveX\XMLSign\SigWinImage\Debug\BuildLog.htm" SigWinImage - 3 error(s), 0 warning(s) |


POSTED ON 15 DEC 2013 / DESSERTS
For the fig-swirl: Melt butter ovr medium heat in a saucepan. Add brown sugar and stir to dissolve. Halve all of the figs and toss in the saucepan with water and lemon juice. Cook over medium heat, stirring frequently, until you hae a chucky-jammy mixture. Add salt with one or two stirs, set aside and let cool completely.
Ice cream; In a small pot over medium heat, combine milk, and granulated sugar until sugar is completely dissolved and the milk is just barely lukewarm. Wisk in the egg yolks. Set mixture in the fridge and wait until the fig mixture is cooled.
Using an ice creme machine, pour liquids into the frozen basin and process according to manufacturer instructions, i.e., let spin and thicken for 20 minutes before adding mascarpone, fig jam mixture, and the nuts. Continue to process for +/- 10 minutes. Pour semi frozen mixture into a pyrex dish or glass tupperware. Freeze for at least two hours before serving.
//commentFood enthusiast, photography fan. Add a pinch of raw foodism and that's pretty much who I am


Currently (Fall 2019) I am a senior Computing/Mathematics double major with hopes to become a software engineer after graduation. Through many of my classes I have been able to firmly grasp C++ and used that knowledge to learn other languages, mainly Python, Java, and R. So far, I have taken courses covering data structures and algorithms, computer architecture, computer organization, data mining, discrete mathematics, linear algebra, and currently taking courses over software development, combinotorics, and cryptography.
I have previously worked in the department of Computer Science working under Dr. Teresa Leyk as a peer teacher for CSCE 206 and 221. Together with other peer teachers, we were able to help students grasp data structures and general programming skills to prepare them for their upper level courses. Some of the topics included linked lists, trees, hash tables, queues, stacks, unit testing, linux, and more. Through this job, I was able to not only assist others with their studying , but honed my skills of data structures, debugging, and explaining my own code to others.


Previous | Contents | Index | Next
(Note: the Windows version of this game is called NETGAME.EXE
to avoid clashing with Windows's own NET.EXE
.)
I originally saw this in the form of a Flash game called FreeNet [1], written by Pavils Jurjans; there are several other implementations under the name NetWalk. The computer prepares a network by connecting up the centres of squares in a grid, and then shuffles the network by rotating every tile randomly. Your job is to rotate it all back into place. The successful solution will be an entirely connected network, with no closed loops. As a visual aid, all tiles which are connected to the one in the middle are highlighted.
[1] http://www.jurjans.lv/stuff/net/FreeNet.htm
On Android, please touch for left click and long press for right click. Also note that where this manual refers to pressing a letter on the keyboard, the Android version has icons at the bottom of the screen instead (Control and Shift are not available). There is also an optional "Night mode" which uses darker colours in low light.
This game can be played with either the keyboard or the mouse. The controls are:
The following controls are not necessary to complete the game, but may be useful:
(All the actions described in section 2.1 are also available.)
These parameters are available from the ‘Custom...’ option on the ‘Type’ menu.
The grid generation in Net has been carefully arranged so that the barriers are independent of the rest of the grid. This means that if you note down the random seed used to generate the current puzzle (see section 2.2), change the Barrier probability parameter, and then re-enter the same random seed, you should see exactly the same starting grid, with the only change being the number of barriers. So if you're stuck on a particular grid and need a hint, you could start up another instance of Net, set up the same parameters but a higher barrier probability, and enter the game seed from the original Net window.
On platforms that support user preferences, the ‘Preferences’ option on the ‘Game’ menu will let you configure when loops are highlighted as errors. By default, they're always highlighted; by changing this option, you can ask for a loop to be highlighted only if every tile forming part of the loop is locked. This avoids the loop highlighting acting as a spoiler for available deductions about squares you haven't even looked at yet.


Before Change
stacks = ops.shape(net)[0] // gan.batch_size()
split_shape = ops.shape(net)
split_shape[-1] = gan.channels()
split_shape[0] //= stacks
enhancers = gan.skip_connections.get_array("progressive_enhancement", split_shape)
concats = [net]
After Change
x = self.add_noise(self.gan.inputs.x)
x = tf.image.resize_images(x,new_shape, 1) //TODO what if the input is user defined? i.e. 2d test
size = [ops.shape(net)[1], ops.shape(net)[2]]
enhancers = [tf.image.resize_images(enhance, size, 1) for enhance in enhancers]
enhance = tf.concat(axis=0, values=[x]+enhancers)
// progressive growing


 You agree to be bound by the terms of Dimagi's Terms of Service and Business Agreement. By accepting this agreement, your are acknowledging you have permission and authority to accept these terms. A Dimagi representative will notify you when the transfer is complete. {% endblocktrans %}
{% blocktrans %} Sorry this transfer request has expired. {% endblocktrans %}
{% endif %}


fun supportDelta(supportDelta: Double): RuleGeneratorBuilder<ItemType>
Sets the value, the minimum support should be decreased by after each iteration, when trying to find a specific number of frequent item sets.
supportDelta
- The value, which should be set. The value must be greater than 0


-    ☰
-
-
- Contact Us
- About Us
- Register
LEO MAN
Leo man in love
This is a man who falls in love in an incredibly warm and cuddly way. Just think of a tamed lion, purring and making room to sit in somebody’s lap. Love will only strengthen his ego and he will truly enjoy the chase of his “prey”. Since he belongs to fixed signs of the zodiac, he might have trouble letting go of relationships that are outdated, holding on to shreds of emotion instead of searching for a new partner. This can take away a lot of his energy and he should always be free to feel the same warm and cuddly sensation that makes his heart jump.
Leo man in relationships
When he finds himself in a relationship, he will do anything to show how gallant, confident and powerful he is. This is not something that he does out of insecurity, but something that he finds necessary to seduce the subject of his desire.  If anyone is waiting for Prince Charming, he might be found in Leo, for he feels and acts like royalty. Unfortunately, this can sometimes be taken quite literally and he can act as if he is a spoiled prince, lazy, bossy and thinking that he is the center of the Universe. However, he might still win you over by pointing out his incredible attributes, but turn out to be quite a disappointment if you hope he will become less selfish.
Can you trust your Leo man
In most cases, Leo man can be trusted, except when he simply doesn’t care about you. This is not the man that will spend his time in guilt, not secure about his decisions and choices of partners. He will lie only if he doesn’t want to deal with the boring consequences of his words, never out of fear. In general, this is not the man who is afraid, and this is what can make him such a faithful and trustful partner. Still, there are times when he doesn’t see the point of honesty because he doesn’t really want to get too attached or close to anyone. If you want to see if he should be trusted, don’t obsess. Instead, simply ask yourself – do you feel loved?
Understanding Leo men
To understand Leo, you would need to know his weaknesses and they are sometimes hard to come by. He is not that secretive, he just doesn’t want to talk about things that are emotionally difficult, and he would rather spend time in his pool of personal satisfaction than swim in negative emotions. The most important thing to remember about Leo is that his seemingly superficial nature is not superficial at all. The depth of Leo reaches to a point in which no compromise has to be made for everyone around him to be happy. He has a difficult task as a leader and a ruler, and he should be respected because of the responsibility that follows, no matter if he is aware of it or not.
Leo Man Likes and Dislikes
Leo is openhearted, grand in his gestures and easy to talk to. He is comfortable to be with, for he will enjoy a relationship full of respect and warmth. He has this beautiful hug that no other sign has. On the other hand, he can be bossy, pretentious and self-involved to the point in which it is impossible to be his partner.
How to choose a gift for your Leo Man
Choose something that will accent his manly physique or character. He wants to show his big shoulders or his great hair. Pack your gift in warmth, in orange, yellow and red colors. Stick to things with value that show how much you respect and cherish him. Buy him a golden watch or an expensive pen. He will like thoughtful gifts just as much, but only if you truly understand his core and are able to pick out something he always dreamed of.


Iso-surface extraction into polygons.
This class, with only one static method provides an interface to
an algorithm which will, when given a function mapping each point
in a given AABB to a scalar value extract approximated polygons
which represent the region of the AABB where the function returns
a negative value.
This function could be a mathematical function like the equation of
a circle:
function (x, y) return (x*x + y*y) - r*r
Or something more practical like the biased alpha value interpolated
from a Bitmap:
function (x, y) {
var ix = if (x < 0) 0 else if (x >= bitmap.width - 1) bitmap.width - 2 else Std.int(x);
var iy = if (y < 0) 0 else if (y >= bitmap.height - 1) bitmap.height - 2 else Std.int(y);
var fx = x - ix;
var fy = y - iy;
var gx = 1 - fx;
var gy = 1 - fy;
var a00 = bitmap.getPixel32(ix, iy) >>> 24;
var a01 = bitmap.getPixel32(ix, iy + 1) >>> 24;
var a10 = bitmap.getPixel32(ix + 1, iy) >>> 24;
var a11 = bitmap.getPixel32(ix + 1, iy + 1) >>> 24;
return 0x80 - (gx*gy*a00 + fx*gy*a10 + gx*fy*a01 + fx*fy*a11);
}
For 'flash', we must wrap this in an IsoFunction interface to be used
by MarchingSquares for performance reasons:
class BitmapIsoFunction implements nape.geom.IsoFunction {
public function iso(x:Float, y:Float):Float {
...
}
}
This function is converted into a set of polygons by sampling along regular
grid points, and then recursively interpolating along cell edges based on
the function provided to find the point in space along that edge where the
function is approximately 0.
From this we generate polygons in each grid cell, which are then by default
combined into larger, weakly simply polygons suitable for use in the
decomposition routines of GeomPoly like convexDecomposition!
The runtime of the algorithm is O(N+K) for N number of cells and K number
of output vertices (A final pass is made to remove unnecessary vertices).
We can, optionally provide a subgrid argument which, when non null will invoke this algorithm seperately on each subgrid cell of the region in space, instead of on the entire region at once. This can be very useful as shown in the DestructibleTerrain demo where regions of a terrain are recomputed with marching squares without needing to regenerate the whole of the terrain.


AKAN NAMES
Short Description
The Akan people of Ghana frequently name their children after the day of the week they were born and the order in which they were born. These "day names" have further meanings concerning the soul and character of the person.This website helps a user know their Akan name by simply filling in their birthdate and selecting their gender.


|
PORTED Mouse
|
Go to the source code of this file.
Macros | |
| #define | SPEEDMAX_EXPLORE 225 |
| #define | SPEEDMAX_STRAIGHT 225 |
| #define | SPEEDMAX_SPIN_TURN 225 |
| #define | SPEEDMAX_SMOOTH_TURN 70 |
| #define | STEERING_ERROR_MAX 32 |
| #define | MOTOR_IDLE_51Hz (F_MOTOR_TIMER/51) |
| #define | MOTOR_IDLE_57Hz (F_MOTOR_TIMER/57) |
| #define | STEPS_FOR_ONE_METER (8248L) |
| #define | STEPS_FOR_360DEG (2303L) |
| #define | MM(X) (((X) * STEPS_FOR_ONE_METER)/1000L) |
| #define | DEG(X) (((X) * STEPS_FOR_360DEG )/360L) |
| #define | LD_CAL 150 |
| #define | RD_CAL 150 |
| #define | LF_CAL 190 |
| #define | RF_CAL 165 |
| #define | LD_NOMINAL 100L |
| #define | RD_NOMINAL 100L |
| #define | LF_NOMINAL 100L |
| #define | RF_NOMINAL 100L |
| #define | FRONT_WALL_INTERFERENCE_THRESHOLD 300 |
| #define | DIAG_THRESHOLD 40 |
| #define | FRONT_THRESHOLD 20 |
| #define | LEFT_FRONT_ERROR_MIN 5 |
| #define | RIGHT_FRONT_ERROR_MIN 5 |
| #define | LEFT_EDGE_OFFSET MM(185L) |
| #define | RIGHT_EDGE_OFFSET MM(185L) |
| #define | SENSOR_OCCLUDED_LEVEL 100 |
Variables | |
| const int | SYSTICK_FREQUENCY = 250 |
| #define DEG | ( | X | ) | (((X) * STEPS_FOR_360DEG )/360L) |
Definition at line 52 of file parameters.h.
| #define DIAG_THRESHOLD 40 |
Definition at line 76 of file parameters.h.
| #define FRONT_THRESHOLD 20 |
Definition at line 77 of file parameters.h.
| #define FRONT_WALL_INTERFERENCE_THRESHOLD 300 |
Definition at line 73 of file parameters.h.
| #define LD_CAL 150 |
Definition at line 57 of file parameters.h.
| #define LD_NOMINAL 100L |
Definition at line 65 of file parameters.h.
| #define LEFT_EDGE_OFFSET MM(185L) |
Definition at line 83 of file parameters.h.
| #define LEFT_FRONT_ERROR_MIN 5 |
Definition at line 79 of file parameters.h.
| #define LF_CAL 190 |
Definition at line 60 of file parameters.h.
| #define LF_NOMINAL 100L |
Definition at line 67 of file parameters.h.
| #define MM | ( | X | ) | (((X) * STEPS_FOR_ONE_METER)/1000L) |
Definition at line 50 of file parameters.h.
| #define MOTOR_IDLE_51Hz (F_MOTOR_TIMER/51) |
Definition at line 42 of file parameters.h.
| #define MOTOR_IDLE_57Hz (F_MOTOR_TIMER/57) |
Definition at line 43 of file parameters.h.
| #define RD_CAL 150 |
Definition at line 58 of file parameters.h.
| #define RD_NOMINAL 100L |
Definition at line 66 of file parameters.h.
| #define RF_CAL 165 |
Definition at line 61 of file parameters.h.
| #define RF_NOMINAL 100L |
Definition at line 68 of file parameters.h.
| #define RIGHT_EDGE_OFFSET MM(185L) |
Definition at line 84 of file parameters.h.
| #define RIGHT_FRONT_ERROR_MIN 5 |
Definition at line 80 of file parameters.h.
| #define SENSOR_OCCLUDED_LEVEL 100 |
Definition at line 88 of file parameters.h.
| #define SPEEDMAX_EXPLORE 225 |
Definition at line 32 of file parameters.h.
| #define SPEEDMAX_SMOOTH_TURN 70 |
Definition at line 35 of file parameters.h.
| #define SPEEDMAX_SPIN_TURN 225 |
Definition at line 34 of file parameters.h.
| #define SPEEDMAX_STRAIGHT 225 |
Definition at line 33 of file parameters.h.
| #define STEERING_ERROR_MAX 32 |
Definition at line 38 of file parameters.h.
| #define STEPS_FOR_360DEG (2303L) |
Definition at line 47 of file parameters.h.
| #define STEPS_FOR_ONE_METER (8248L) |
Definition at line 46 of file parameters.h.
| const int SYSTICK_FREQUENCY = 250 |
Definition at line 44 of file parameters.h.


Introduction
bds is intended as a scripting language for big data pipeline.
What?
bds is a cross-system scripting language for working with big data pipelines in computer systems of different sizes and capabilities.
Why?
Working with heavyweight computation and big data pipelines involves making use of several specialized programs. Those specialized routines need to be scheduled, called and coordinated; their progress need to be tracked and their results logged. That is the job of another script or program. This is when bds becomes extremely handy.
Developing traditional shell scripts or small programs to coordinate data pipelines presents a fundamental dilemma. It is not cross-platform, it simply does not work on all environments or it needs adaptations and re-work for the same thing to work on a laptop, server, server farm, cluster and cloud. Often it is simply not possible. Because of that, developing big data pipelines for a different environment is time consuming. The behaviour on the target environment cannot be assumed to be an exact extrapolation of the results obtained on the development environment. This not only is a waste of time, money and energy, it is also reliable source of frustration.
bds is the solution to the problem.
With bds, creating jobs for big data is as easy as creating a shell script and it runs seamlessly on any computer system, no matter how small or big it is. If you normally use specialized programs to perform heavyweight computations, then bds is the glue to those commands you need to create a reliable pipeline.
How?
Benefits of bds
- Reduced development time Spend less time debugging your work on big systems with a huge data volumes. Now you can debug the same jobs using a smaller sample on your computer. Get immediate feedback, debug, fix and deploy when it's done. Shorter development cycles means better software.
- System independent Cross-system, seamless execution, the same program runs on a laptop, server, server farm, cluster or cloud. No changes to the program required. Work once.
- Easy to learn The syntax is intuitive and it resembles the syntax of most commonly used programming languages. Reading the code is easy as pi.
- Automatic Checkpointing If any task fails to execute, bds creates a checkpoint file, serializing all the information from the program. Want to restart were it stopped? No problem, just resume the execution from the checkpoint.
- Automatic logging Everything is logged (
-log
command line option), no explicit actions required. Every time you execute a system command or a task, bds logs the executed commands, stdout & stderr and exit codes. - Clean stop with no mess behind You have a bds running on a terminal and suddenly you realized there is something wrong... Just hit Ctrl-C. All scheduled tasks and running jobs will be terminated, removed from the queue, deallocated from the cluster. A clean stop allows you to focus on the problem at hand without having to worry about restoring a clean state.
- Task dependencies In complex pipelines, tasks usually depend on each other. bds provides ways to easily manage task dependencies.
- Avoid re-work Executing the pipeline over and over should not re-do jobs that were completed successfully and moreover are time consuming. Task dependency based on timestamps is a built-in functionality, thus making it easy to avoid starting from scratch every time.
- Built in debugger Debugging is an integral part of programming, so it is part of
bds
language. Statementsbreakpoint
anddebug
make debugging part of the language, instead of requiring platform specific tools. - Built in test cases facility Code testing is performed in everyday programming, so testing is built in
bds
.
Paper & Citations
If you are using bds in an academic environment, please cite our paper:
bds: A scripting language for data pipelines
P. Cingolani; R. Sladek; M. Blanchette
Bioinformatics 2014;
doi: 10.1093/bioinformatics/btu595
A word about performance
bds is meant to be used in the context or heavyweight computations. Potential delays incurred by bds should not affect the overall time.
Think about it this way: If you are invoking a set of programs to perform big data computations, these programs usually take hours or days to run. The fact that bds takes a few milliseconds more to invoke those programs, really doesn't make any difference.
Why is it called "bds"
Because that's the lamest name I could find.
Disclaimer
bds is experimental and under heavy development. Use at your own risk. Know side effect include: computer explosions, instant decapitation, spontaneous human combustion, and dead kittens.


--- layout: page title: "Now" description: "Nownownow" ---
Here is what I'm doing now.
Last updated: 21 August 2023


I am a recent graduate having done a robotics M.S. at Oregon State University. I worked in the Personal Robotics Group with Dr. Bill Smart. My research interests involved the effects robots play in the workspace like hospitals and the dynamics of human-robot interactions over long periods of time. In my spare time, I like to watch movies, cook, and hunt the web for deals.
Developed and built an enclosed conveyor belt system that can help disinfect supplies with UV-C light. This conveyor system will work in conjunction with a robot that will allow the robot to enter and exit autonomously with the help of an automatic door. Inside, the robot will be exposed to UV-C light that will inactivate any harmful viruses like COVID-19 on the supplies. Path planning algorithms, electronics, and hardware for the conveyor belt system are currently in the developmental process.
Video Link: UV-C Light Sanitation v1A Husky UGV was utilized to offload construction workers from high risk tasks. The task selected for this research was road caulking. To perform road caulking, custom attachments were made on the Husky to mount a 18V caulking gun. Simulation in Gazebo and real-life trails were done with the Husky to ensure the road caulking was performed accurately.
Video Link: Road Caulking DemoThis project deals with the detection of artificial red bombs using a TurtleBot2, Kinect, and USB webcam. After detecting a potential bomb, its location will be added into the robots global cost map. This allows the robot to plan navigation around the bombs and indicate to the user where the bombs are on the map. Preliminary test was conducted in simulations to help model the functionality of the minesweeping robot. The code was then debugged and transferred to run on the real TurtleBot2. The robot was successful to autonomously navigate through the environment with a prior known map and detect the red artificial bombs with a USB webcam separately. The TurtleBot2 was however unsuccessful to do both tasks simultaneously.
Video Link: Minesweeper Robot SimulationRobots often have difficulties navigating through human social interactions, in part due to the need to recognizably emulate human gestures and expressive motions. We approach the problem of determining superior poses and path planning algorithms for a human like handshake. To do so, this project includes a study on several key aspects of the handshake approach: the starting pose, the ending pose, and the path planning for intermediate poses and motion. To minimize false assumptions, a wide set of poses are arranged for initial screening and a final survey was sent out. We also present an RRT* variation with the objective of creating a maximally smooth trajectory. To deploy and test the produced handshake motion in situ, a UR5e executes the motion with input on the appropriately scaled poses from a facial recognition and locating system. We present the results of a survey of the human reception to several poses and existing path planning algorithms.
Video Link: Human-Robot Handshake with the UR5eBuilt and tested a high-performance DC copter fan to be controlled at various angles using the microcontroller Arduino utilizing a PID control system. Analyzed and derived the effects of different gains on the system with mixed inputs and outputs
Modeled and 3D printed a wearable device to house custom made electromagnet, electronics, and regular neodymium magnets using the computer aided design software SolidWorks. Designed an experimental apparatus to test and validate the functionality of the device. Used a slow-motion camera to record and compute the reduction in amplitude of using the device, the natural frequency of the electromagnet, and the amplitude of the test instrument with various weights.
Devised an automated bartender to serve three unique types of cocktails which were ordered via a pushbutton and LCD screen. Won overall best group project and used project to win the Mahanty Award Scholarship for Fall 2014.
Under the department of energy, worked to help detect bird impacts on Wind Turbines. Used prior made impact detection devices to see if recorded data can be distinguishable with the use of machine learning and digital signal processing.
Grade assignments and hold office hours to help assist students in understanding the fundamentals of dynamics. Work closely with dynamics professor to asses and cater different learning experiences from feedback during office hours.
Developed the android application Hmonglish with Android Studios which teaches basic Hmong language through voice recordings and have an impact of over 1000+ installs, 245 active installs, and 4.5/5 rating. Work along with Hmong teaching professionals to build and record categories for basic vocabulary, artistes to design compatible digital images, and group members to design and launch new updates to the app.
HmonglishTaught all grades of students from K-12, carried out lessons plans left by instructors, helped summaries the days progress, and ensured the safety for all students.
Designed and evaluated over 600 solar photovoltaic systems for residential homes (9000kW+ houses producing clean energy) using a combination of AutoCAD and custom software tools. Consistently ranked top for design quality having 100% error free jobs for six months running. Communicated verbally and in writing with multiple levels in the organization to ensure accurate designs and warn crew members about any precautionary safety hazards prior to each installation. Determined the feasibility of each design by doing structural analysis, electrical load calculations, shade readings, and thoroughly checking through the home’s interior and exterior photos for safety concerns.
GPA: 3.91/4.0
Major GPA: 3.91/4.0


CSS Grid, Finally...
Hi there! I’m a bike messenger by day, aspiring actor by night, and this is my website. I live in Los Angeles, have a great dog named Jack, and I like piña coladas. (And gettin’ caught in the rain.)
The XYZ Doohickey Company was founded in 1971, and has been providing quality doohickeys to the public ever since. Located in Gotham City, XYZ employs over 2,000 people and does all kinds of awesome things for the Gotham community.
Whats Up Today:
| Colby Covington Mr. Covington is an American mixed martial artist who gets calls from Donald Trump. |
| Dustin May - Gingergaard... |
| Draymond Green - 4 years $100 Million to stay with the Dubs. |
| Descendants 3 So this movie coming out is co-starring a young man that passed away I guess? |
| ASAP Rocky Wow! The government just got heavy with Sweden over a rapper. |
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus magna. Cras in mi at felis aliquet congue. Ut a est eget ligula molestie gravida. Curabitur massa. Donec eleifend, libero at sagittis mollis, tellus est malesuada tellus, at luctus turpis elit sit amet quam. Vivamus pretium ornare est.
#header h1 a {
display: block;
width: 300px;
height: 80px;
}


Các công ty hàng đầu
Economy
Some quick example text to build on the card title and make up the bulk of the card's content.
Read more
Chemistry
Some quick example text to build on the card title and make up the bulk of the card's content.
Read more
Journalism
Some quick example text to build on the card title and make up the bulk of the card's content.
Read more
Computer science
Some quick example text to build on the card title and make up the bulk of the card's content.
Read more


Preparation time
less than 30 mins
Cooking time
30 mins to 1 hour
Serves
Serves 4
Boneless chicken breasts browned in a pan then covered in a rich tomato sauce with onions and herbs and topped with mozzarella make a delicious supper. Served with butter bean mash and salad, it provides a healthy and satisfying meal.
With a GI of 36 this meal is
high protein, low GI
and provides 472 kcal per portion.
Season the chicken breasts with salt and pepper. Spray a large, deep non-stick flameproof frying pan or sauté pan with oil and place over a high heat. Cook the chicken on each side for 3 minutes or until lightly browned. Transfer to a plate.
Reduce the heat to low, spray a little more cooking oil into the pan and cook the onion for 4-5 minutes, stirring until softened and lightly browned. Add the garlic and cook for a few seconds.
Pour in the tomatoes. Stir in the tomato purée, oregano, olives and 300ml/10fl oz cold water. Bring to the boil and cook for 5 minutes, stirring regularly. Reduce the heat to a gentle simmer and add the chicken. Cook for 10 minutes, stirring occasionally, until the chicken is tender and cooked through. Season to taste.
Preheat the grill to its hottest setting. Top the chicken and sauce with the sliced mozzarella. Sprinkle with ground black pepper. Place under the hot grill and cook for 2-3 minutes or until the cheese melts.
For the butter bean mash, spray a small non-stick saucepan with cooking oil and place over a medium heat. Add the onion and cook for 3 minutes. Add the garlic and cook for 1 further minute.
Put the beans in a food processor with 100ml/3½fl oz water, a good pinch of salt and pepper. Add the cooked onion and garlic and blend to a thick purée. Spoon back in to the saucepan and heat, stirring constantly until hot. Add a good squeeze of lemon and season to taste.
Divide the butterbean mash between 4 plates and add the chicken and sauce. Serve with freshly cooked vegetables or salad.


Before Change
Returns:
TensorType: Distribution inputs for sampling actions.
return self.action_model(model_out)
def policy_variables(self):
Return the list of variables for the policy net.
After Change
// Model outs may come as original Tuple observations, concat them
// here if this is the case.
if isinstance(self.action_model.obs_space, Box):
if isinstance(model_out, (list, tuple)):
model_out = torch.cat(model_out, dim=-1)
elif isinstance(model_out, dict):
model_out = torch.cat(list(model_out.values()), dim=-1)
out, _ = self.action_model({"obs": model_out}, [], None)
return out
def policy_variables(self):


Brief meeting summary.
Micro-meeting duration.
Full description of meeting.
Organizer name.
Organizer email address.
Meeting date.
Meeting start time.
Meeting end time.


Before the Apollo 11 Lunar Module, the Eagle, landed on the Moon, there was another, called Snoopy.
They were identical, these two odd looking spacecraft with spindly legs and paper thin walls.
As she crossed from the Leakey to the primitive lunar module, Gan recognized the faded red, white, and blue symbol that represented the classic 50-state alliance at the height of its global preeminence, a time of technological triumph, social unrest, and dietary disaster. She noted the fine coating of dust that covered the lunar module ascent stage and took great pains not to disturb it, except for one small patch. There, she wiped clear a small area to reveal the image of a stylized dog with a long snout. Above the dog was the word "Snoopy."


--- layout: post status: publish published: true title: Virtual PC author: display_name: Tomas Restrepo login: tomasr email<EMAIL_ADDRESS>url: http://winterdom.com/ author_login: tomasr author_email<EMAIL_ADDRESS>author_url: http://winterdom.com/ wordpress_id: 504 wordpress_url: http://winterdom.com/2002/12/virtualpc-2 date: '2002-12-28 14:27:58 +0000' date_gmt: '2002-12-28 14:27:58 +0000' categories: - Tools tags: [] comments: - id: 354 author: Bryce author_email<EMAIL_ADDRESS>author_url: http://www.ntwizards.net/blog/ date: '2002-12-28 23:44:47 +0000' date_gmt: '2002-12-28 23:44:47 +0000' content: |
VPC probably has the same issue as VMWare with wireless networks -- the spec expressly disallows MAC spoofing.
http://www.vmware.com/support/reference/common/wireless_net.html
- id: 355 author: Tomas Restrepo author_email<EMAIL_ADDRESS>author_url: http://www.winterdom.com/weblog date: '2002-12-30 05:08:42 +0000' date_gmt: '2002-12-30 05:08:42 +0000' content: |Yep, sounds like it might be the same issue indeed, Bryce; thanks for the pointer.
I still didn't found anything related to it on the Connectix site, though...
---I downloaded Windows .NET Server RC2 earlier this week. I had RC1 running on my laptop (well, my only machine, really) dual booting with my main OS (WinXP). Because of that, I wasn't really using it much.
There's been some talk about running RC2 on VMWare, so I decided to try something similar. However, instead of going to VMWare, I decided to give Connectix Virtual PC software a try.
I was, frankly, quite impressed. Win.NET Server installed without a hitch, just using the default configuration. Here it is running on my WinXP:
I've only found two small issues with it. One: Installation is slow; it took me almost 3 hours to get everything up and running. Funny enough, it wasn't that my machine was too slow, as VPC was barely using 30% of my processor time. However, performance for the actual OS running seems quite decent to me (better than I expected, frankly). The second issue is that I haven't been able to get the Virtual Switch networking feature to work, and only the NAT option works. However, I think this has to do with the fact that I'm using wireless on my laptop now, and VPC seems to have trouble recognizing the Virtual Switch driver on the wireless card, and trying to use the one on the ethernet port, which was unplugged.
Other than that, it seems pretty cool!


| Total net profit | -3.62 | Gross profit | 0.84 | Gross loss | -4.46 |
| Profit factor | 0.19 | Expected payoff | -0.1 | ||
| Absolute drawdown | -3.67 | Maximal drawdown (%) | 3.53 (-2521.43%) | ||
| Total trades | 35 | Profit trades (% of total) | 9 (25.71%) | Loss trades (% of total) | 26 (74.29%) |
| Long positions (won %) | 14 (28.57%) | Short positions (won %) | 21 (23.81%) | ||
| Largest | profit trade | 0.25 | loss trade | -0.32 | |
| Average | profit trade | 0.09 | loss trade | -0.17 | |
| Minimum | profit trade | 0.01 | loss trade | -0.01 | |
| Maximum | take profit in pips | 167.4 | stop loss in pips | -26.9 | |
| Average | take profit in pips | 98.9 | stop loss in pips | -14.5 | |
| Minimum | take profit in pips | -0.8 | stop loss in pips | -10.4 | |
| Maximum | Reward-Risk | 15.6 | Duration in minutes | 20082 | |
| Average | Reward-Risk | 7.4 | Duration in minutes | 2593.0 | |
| Minimum | Reward-Risk | 0.0 | Duration in minutes | 15 | |
| Maximum | consecutive wins (profit in money) | 2.0 (0.24) | consecutive losses (loss in money) | 7.0 (-1.23) | |
| Average | consecutive wins | 1.0 | consecutive losses | 3.0 |
| Total net profit | -1.68 | Gross profit | 0.17 | Gross loss | -1.85 |
| Profit factor | 0.09 | Expected payoff | -0.12 | ||
| Absolute drawdown | -1.68 | Maximal drawdown (%) | 1.54 (-1100.0%) | ||
| Total trades | 14 | Profit trades (% of total) | 4 (28.57%) | Loss trades (% of total) | 10 (71.43%) |
| Largest | profit trade | 0.05 | loss trade | -0.28 | |
| Average | profit trade | 0.04 | loss trade | -0.18 | |
| Minimum | profit trade | 0.03 | loss trade | -0.01 | |
| Maximum | take profit in pips | 160.5 | stop loss in pips | -21.4 | |
| Average | take profit in pips | 89.1 | stop loss in pips | -16.0 | |
| Minimum | take profit in pips | -0.8 | stop loss in pips | -14.0 | |
| Maximum | Reward-Risk | 11.3 | Duration in minutes | 20082.0 | |
| Average | Reward-Risk | 5.7 | Duration in minutes | 2950.4 | |
| Minimum | Reward-Risk | 0.0 | Duration in minutes | 131.0 | |
| Maximum | consecutive wins (profit in money) | 1.0 (0.04) | consecutive losses (loss in money) | 4.0 (-0.7) | |
| Average | consecutive wins | 1.0 | consecutive losses | 2.0 |
| Total net profit | -1.94 | Gross profit | 0.67 | Gross loss | -2.61 |
| Profit factor | 0.26 | Expected payoff | -0.09 | ||
| Absolute drawdown | -1.99 | Maximal drawdown (%) | 1.83 (-1143.75%) | ||
| Total trades | 21 | Profit trades (% of total) | 5 (23.81%) | Loss trades (% of total) | 16 (76.19%) |
| Largest | profit trade | 0.25 | loss trade | -0.32 | |
| Average | profit trade | 0.13 | loss trade | -0.16 | |
| Minimum | profit trade | 0.01 | loss trade | -0.02 | |
| Maximum | take profit in pips | 167.4 | stop loss in pips | -26.9 | |
| Average | take profit in pips | 105.4 | stop loss in pips | -13.6 | |
| Minimum | take profit in pips | 0.4 | stop loss in pips | -10.4 | |
| Maximum | Reward-Risk | 15.6 | Duration in minutes | 12944.0 | |
| Average | Reward-Risk | 8.5 | Duration in minutes | 2354.7 | |
| Minimum | Reward-Risk | Duration in minutes | 15.0 | ||
| Maximum | consecutive wins (profit in money) | 2.0 (0.44) | consecutive losses (loss in money) | 7.0 (-1.23) | |
| Average | consecutive wins | 1.0 | consecutive losses | 4.0 |


The debate:
Since the dawn of time, guitarists everywhere have wondered: What is better the Les Paul or the Stratocaster? Both are staples of the rock universe but surely one must be superior.
The Gibson Les Paul was first released in 1952 after being designed and endorsed by Mr. Les Paul himself. It quickly spread to be mass produced and its versatility allows its use in many genres spreading from jazz to heavy metal.
The Fender Stratocaster, or strat, was invented in 1954. Featuring a double cutaway and an iconic top "horn", the guitar is the single best selling guitar to hit the market.
Led Zeppelin's Jimmy Page playing a face melting solo on his "No. 1"Les Paul
Stevie Ray Vaughn playing his iconic vintage strat which he also referred to as "No 1"
The Argument:
In order to really understand these two pieces of american history, we need to take a closer comparison of them. Below is a really beautiful table to illustrate the differences:
|
Statocaster |
Les Paul |
| Sound |
Brighter sharper sound |
Round Warm Sound |
| Weight |
8 lbs |
12 lbs |
| Pickups/Knobs |
Three single-coil pickup with 5 settings |
Dual humbucker pickup with 3 settings |
| Price Range |
$600-1,700 |
$700-2,300 |
| Famous Users |
- Jimi Hendrix
- Jeff Beck
- Mark Knopfler
- Eric Clapton
- David Gilmour
|
- Slash
- Joe Bonamassa
- Duane Allman
- Bob Marley
- Pete Townshend
|
| Famous Performances |
|
|
The Conclusion:
The answer is clear, there can only be one guitar to come out on top of this debate and it is obvious the stratocaster is the clear winner. The Les Paul is no doubt a peice of junk as the validity of this argument was in question since the start.