CS 377 - Database Systems
Course Overview
This is an introduction course on database systems. It introduces the fundamental concepts of the design and use of database systems. We will introduce the Entity-relationship model used to design a database. The main focus of the course will be relational database systems where we will study the relational data model and the SQL query language for accessing the data maintained by relational database systems. We will also give a brief overview of database systems implementation, including topics such as storage management and transaction processing.
Prerequisites: CS171
Syllabus
Course Logistics
- Piazza: All annoucements, assignment clarifications, and slide corrections will be posted here. Make sure you check it on a regular basis.
- Office Hours:
- Joyce Ho: W 1:30PM-3:30PM; Th 9:30AM-11:30AM @MSC W414
Textbook
- (Recommended) Fundamentals of Database Systems (6th / 7th edition), by Ramez Elmasri & Shamkant B. Navathe
- (Supplemental) Database System Concepts, by Abraham Silberschatz, Henry Korth, & S. Sudarshan
- (Supplemental) Database Systems: The Complete Book, by Hector Garcia-Molina, Jeffrey D. Ullman, & Jennifer Widom
Assignment (Homeworks & Projects) Policy
- Assignments are due electronically at 11:59 PM. The assignment will specify whether the submission is via Gradescope (homeworks) or Canvas (projects).
- Each student receives six 24-hour “late days” that can be used on any of the 7 assignments (4 homeworks, 2 programming projects, 1 final project) throughout the semester. No more than 3 late days may be used on any single assignment.
- Use your late days wisely, no more late days remaining means you will receive zero credit for any late assignment
- Additional extensions on assignments will be granted with appropriate documentation from the Office of Undergraduate Education (OUE)
Honor Code and Collaboration Policy
All class work is governed by the College Honor Code and the Department Statement of Policy on Computer Assignments. While we encourage you to discuss assignments with other students, any code and writeups must be written by yourself. It is not okay to share code or write code collaboratively (this includes posting and/or sharing your code publicly). Apparent copies from any source, including your colleagues and internet sites, will be referred to the Emory Honor Council. Every programming assignment must have a README file with the following comment:
/* THIS CODE IS MY OWN WORK, IT WAS WRITTEN WITHOUT CONSULTING CODE WRITTEN BY OTHER STUDENTS. Your_Name_Here */
Exam Policy
- The midterm will be on 3/8 from 2:30pm-3:45pm (class time).
- Rescheduling the midterm is not permitted except in emergencies with appropriate documentation from OUE.
- The final will be on 5/7 from 3:00pm-5:30pm and cannot be rescheduled under any circumstance.
Grading
Your grade will be determined by a weighted average of all the graded items. Grades may be curved (up) so that the class mean falls at least in a B range. The class median and mean for each assignment and exam will be announced so you have an idea where you stand. The participation element consists of short bi-weekly quizzes (unannounced), monthly surveys (on Piazza), and class coding questions (on Canvas).
| Component | Weight |
|---|---|
| Homeworks (4) | 16% |
| Programming Projects (2) | 15% |
| Final Project (1) | 18% |
| Midterm | 20% |
| Final | 25% |
| Participation | 6% |
Students with Documented Disabilities
If you have a documented disability and have anticipated barriers related to the format or requirements of this course, or presume having a disability (e.g. mental health, attention, learning, vision, hearing, physical or systemic), and are in need of accommodations for this semester, we encourage you to contact the Office of Accessibility Services (OAS) to learn more about the registration process and steps for requesting accommodations.
If you are a student that is currently registered with OAS and have not received a copy of your accommodation notification letter within the first week of class, please notify OAS immediately. Students who have accommodations in place are encouraged to contact the instructor during the first week of the semester, to communicate your specific needs for the course as it relates to your approved accommodations. All discussions with OAS and faculty concerning the nature of your disability remain confidential.
Schedule
The reading material listed below is optional, but it refers to Fundamentals of Database Systems (7th edition) by Ramez Elmasri & Shamkant B. Navathe. The lecture plan may deviate over the course of the semester.
| # | Date | Topic | Reference (Chapter) | Assignment |
|---|---|---|---|---|
| 1 | 1/18 | Class Cancelled | ||
| 2 | 1/23 | Introduction & Database Concepts | 1,2 | |
| 3 | 1/25 | ER Model | 3 | Homework 1 (due 2/6) |
| 4 | 1/30 | Relational Model | 5,9 | |
| 5 | 2/1 | Relational Algebra | 5 | |
| 6 | 2/6 | Relational Algebra | 8 | Homework 2 (due 2/20) |
| 7 | 2/8 | Relational Calculus | 7 | |
| 8 | 2/13 | SQL: Intro | 6,7 | |
| 9 | 2/15 | SQL: Querying | 6,7 | |
| 10 | 2/20 | SQL: Querying | 6,7 | Project 1 (due 3/6) |
| 11 | 2/22 | SQL: Querying | 6,7 | |
| 12 | 2/27 | SQL: Advanced Queries | 6,7 | |
| 13 | 3/1 | SQL: Advanced Queries | 6,7 | |
| 14 | 3/6 | Midterm Review | ||
| 15 | 3/8 | Midterm | Project 2 (due 3/29) | |
| 16 | 3/20 | Database Design | 14,15 | |
| 17 | 3/22 | Database Design | 14,15 | Homework 3 (due 4/10) |
| 18 | 3/27 | PHP | 11 | |
| 19 | 3/29 | Indexing | 16,17 | Final Project (due 4/30) |
| 20 | 4/3 | Indexing | 16,17 | |
| 21 | 4/5 | Query Processing & Optimization | 18,19 | |
| 22 | 4/10 | Query Processing & Optimization | 18,19 | Homework 4 (due 4/19) |
| 23 | 4/12 | Transaction Management & Concurrency Control | 20,21 | |
| 24 | 4/17 | Transaction Management & Concurrency Control | 20,21 | |
| 25 | 4/19 | NoSQL | 24 | |
| 26 | 4/24 | NoSQL | 24 | |
| 27 | 4/26 | Review |


The specification is intended for discussion within the RDF Stream Processing Community Group. Its content does not yet represent the consensus of the Community Group.
This specification is incomplete.
The metamodel for the abstract syntax of RDF streams is defined in the namespace http://www.w3.org/ns/rsp#
and we use the prefix rsp
for this namespace. Additional prefixes used in this document are the following:
| prefix | namespace IRI | definition |
| rsp | http://www.w3.org/ns/rsp# | The RSP rnamespace |
| rdf | http://www.w3.org/1999/02/22-rdf-syntax-ns# | The RDF namespace [[!RDF-SCHEMA]] |
| rdfs | http://www.w3.org/2000/01/rdf-schema# | The RDFS namespace [[!RDF-SCHEMA]] |
| xsd | http://www.w3.org/2000/10/XMLSchema# | XML Schema Namespace [[!XMLSCHEMA11-2]] |
| owl | http://www.w3.org/2002/07/owl# | The OWL namespace [[!OWL2-OVERVIEW]] |
| owl-time | http://www.w3.org/2006/time# | The OWL-TIME namespace [[OWL-TIME]] |
| prov | http://www.w3.org/ns/prov# |
The PROV namespace [[!PROV-DM]] |
| dul | http://www.ontologydesignpatterns.org/ont/dul/DUL.owl# |
The DOLCE+DnS Ultralet namespace (http://lov.okfn.org/dataset/lov/vocabs/dul) [[DUL]] |
| (others) | (various) | All other namespace prefixes are used in examples only. In particular, IRIs starting with "http://example.com" represent some application-dependent IRI [[!IRI]] |
Let Tall denote the class of all temporal entities. This specification is neutral regarding the formal specification of temporal entities.
We provide an identifier, rsp:TemporalEntity
, for the rdfs:Class
of all
temporal entities.
The following material needs attention from an individual who has reviewed the literature regarding temporal ontologies, including but not limited to http://www.omg.org/spec/DTV/1.0/ http://www.ihmc.us/users/phayes/docs/timeCatalog.pdf http://protege.cim3.net/cgi-bin/wiki.pl?SWRLTemporalOntology http://dl.acm.org/citation.cfm?id=1741341 http://stl.mie.utoronto.ca/publications/psl-chapter.pdf There is more detail in https://github.com/streamreasoning/RSP-QL/issues/25
An instant is an instantaneous point of time on underlying axis and is isomorphic to numbers. Henceforth a time interval is the interval between two instants. A semi-infinite time interval is an interval where one instant is set to infinite. Furthermore if both instants are set to infinite, we call the interval bi-infinite. As a consequence a temporal entity is an entity associated with an instant or a time interval[Dyreson94,Allen83].
Add a out of scope section
Add Stream Profiles and Hierarchies, e.g., combined_time, timepoints, periods, approximate_point, interval_meeting, owltime_instants and owltime_interval
An RSP timestamp predicate P
is an rdf:Property
with range rsp:TemporalEntity
that is
associated, through the rdf:Property
rsp:hasTimePlenum
, with a unique partially-ordered set (poset) of
temporal entities TP ⊆ Tall
, called the time plenum of the predicate.
The time plenum is associated, through the rdf:Property
rsp:hasPartialOrder
,
with a unique partial order ≤P
that is in the class
rsp:ChronologicalPartialOrder
.
The usual mathematical requirements of a partial order MUST be satisfied by an instance of
rsp:ChronologicalPartialOrder
. In particular, for all instances X
, Y
, Z
of the time plenum, the following properties hold:
X ≤P X
X ≤P Y
and Y ≤P X
implies X =
Y
X ≤P Y
and Y ≤P Z
implies X ≤P
Z
. Further, an instance of rsp:ChronologicalPartialOrder
MUST respect the natural order of time.
In
particular, if every time instant within the closure of temporal entity X
is earlier than every time instant within the closure of temporal entity Y
,
then X ≤P Y
(where closure of a time instant t
is defined as
the degenerate interval [t, t]
, and closure of an interval is defined in
the usual way)
The above definition regarding natural order of time depends on the concept of time instant as the primitive of temporal entities that is universal amoung temporal ontologies and has a particular chronological order associated with them. However, not all temporal ontologies have time instants as their primitives, e.g., OMG. Further, branching temporal ontologies have a different set of time primitives than linear ones. So this needs to be fixed.
A timestamped graph is defined as an RDF Dataset under the RDF Dataset semantics that "each named graph defines its own context" (see ) and where a particular triple in the default graph has been designated as the timestamp triple, with the following constraints:
<n, G>
in the RDF Dataset (where
G
is an RDF graph, and n
is an IRI or blank node).<n, p, t>
, where n
is
defined in the previous item, and p
is a timestamp predicate that captures
the relationship between the temporal entity t
, called the timestamp, and
the graph G
.There may be multiple triples in the default graph, including multiple triples using timestamp predicates, but exactly one triple must be designated as the timestamp triple. The objects of any triples that use a timestamp predicate but are not the timestamp triple of the timestamped graph are not called timestamps.
Due to the assertion of the timestamp triple, the context referred to in "each named graph defines its own context" has a temporal aspect to it. Other aspects of this context may be asserted by additional triples in the default graph of the timestamped graph. Such triples are not required to have timestamp predicates, and thus may be about non-temporal aspects of the context, e.g., the authority or the sensor device. That is, we require the context to have a temporal aspect to it, but the context is not limited to temporal aspects. Thus, it would be misleading to call it a "temporal context".
The part of the definition above that points to RDF Dataset semantics really belongs in the semantics section, not in this definition, which should be purely syntax. We need additional informative text that gives the motivation for these definitions.
This definition does not permit the timestamp to be omitted, which is one of the data structures that is considered to be in-scope by the requirements document.
A sequence of RDF graphs (or named graphs, or RDF datasets) MAY be physically received by an RSP engine, which MAY then create an RDF stream from it by adding timestamps, e.g. indicating the time of arrival. The original sequence is not itself an RDF stream.
This definition allows the timestamp to be an IRI or blanknode. Additional information about the timestamp may be provided in the default graph (e.g., through properties in the OWL Time Ontology), but this is not required by the definition of timestamped graph.
A literal-timestamped graph is a timestamped graph whose timestamp
t
is an rdfs:Literal
.
Merge and union of RDF streams with non-literal-timestamped graphs may not be defined. See .
The timestamp predicate p
may be drawn from a community
agreed vocabulary (Issue
10). The timestamp predicate may also be user-defined.
The format in the examples of this document follows TriG, although does not imply any specific serialization or formatting; it simply
shows the data structured according to the RDF stream model. When the default graph of a
timestamped graph contains only one triple, this must be the timestamp triple, so there is
no need of an additional format to designate it. In examples of timestamped graphs having
more than one triple in the default graph, the first triple of the default graph to occur
in the serialization is assumed to be the timestamp triple. Prefixes (e.g.
prov:
, dul:
) are used for readability; their expansions are defined in
Table 1.
A non-normative subsection should be created to hold all the information about the formatting of examples, and there the expansion of all prefixes that are used in examples can be defined.
According to the semantics defined in , the
assertion of the named graph pair means that the graph denoted by :g
entails
the two triples :axel :isIn :RedRoom
and :darko :isIn :RedRoom
,
under whatever entailment regime is being considered. It does not assert those triples
directly, nor does it assert that these triples are actually in that graph. Further, it
does not rule out additional entailments of :g
. These details are best
explained in the semantics section itself, although it would probably be helpful to have
some informative explanation near the beginning to avoid confusion.
Given any two timestamped graphs, TSG1
and TSG2
, we say that
TSG2
covers
TSG1
(denoted TSG1 ≲ TSG2
) if and only if TSG1
and TSG2
have the same timestamp predicate P
and the timestamps,
t1
and t2
resp., satisfy t1 ≤P t2
,
where ≤P
is the temporal partial order associated with the time plenum
of the timestamp predicate P
.
The relation ≲
between timestamped graphs is a preorder (a
reflexive, transitive binary relation). It is not a partial order because it doesn't have
the antisymmetry property (a≲ b
and b≲ a
implies a
= b
.)
An RDF stream
S
consists of a sequence of timestamped graphs, called its elements, such that
elements sharing the same
timestamp predicate are ordered by the partial order associated with this timestamp predicate.
I.e., if a stream S
contains elements S(i)
and S(j)
with i < j
and S(i)
covers S(j)
, then the
timestamps of S(i)
and S(j)
are equal.
If a timestamp predicate occurs in the timestamp triple of an element of an RDF stream, we say it is a timestamp predicate of the stream.
Time-boundedness properties on RDF streams behave better if it is required that the set of temporal entities for each timestamp predicate is pairwise bounded. I.e., for each pair of temporal entities in the set, there is a temporal entity in the set that is an upper bound of both, as well as a temporal entity in the set that is a lower bound of both. This property is not satisfied by branching temporal structures, but could be a requirement of some profile.
The comparability between any pair of elements of an RDF stream must (or should?) be completely determined from the default graphs of those elements, or elements that precede at least one of them. Otherwise the ordering could be revealed by a subsequent element, inducing retroactively an ordering requirement on a previous pair of stream elements.
On the following we may refer to RDF stream simply as stream.
There can be multiple graphs with the same timestamp in the stream.
It has been pointed out that this statement might be problematic, as graphs could no longer be used for punctuation purposes. Comparatively, we have not found a constraint on this in similar models e.g., CQL: there could be zero, one, or multiple elements with the same timestamp in a stream.
Two RDF timestamped graphs TSG1 and TSG2 are isomorphic if and only if there is a bijection M between the nodes, triples, graphs and named graphs in TSG1 and those in TSG2 such that:
The definition of timestamped graphs allows blank nodes to be used as graph names, as well as within triples.
:_1 {...} {:_1, prov:generatedAtTime, t1}
:_2 {...} {:_2, prov:generatedAtTime, t1}
Two RDF streams are S-isomorphic if and only if they have the same set of elements.
:g1 {...} {:g1, prov:generatedAtTime, t1} :g2 {...} {:g2, prov:generatedAtTime, t2} :g3 {...} {:g3, prov:generatedAtTime, t2} :g4 {...} {:g4, prov:generatedAtTime, t3}
:g1 {...} {:g1, prov:generatedAtTime, t1} :g3 {...} {:g3, prov:generatedAtTime, t2} :g2 {...} {:g2, prov:generatedAtTime, t2} :g4 {...} {:g4, prov:generatedAtTime, t3}
Two RDF streams S1 and S2 are B-isomorphic if and only if there is a bijection M between the nodes, triples, graphs, named graphs, and timestamped graphs that occur in S1 and those that occur in S2 such that:
An RDF stream is viewed as being on a single "RDF surface"(see [[BLOGIC]]), so that blank nodes may be shared between any graphs in the stream. For this reason, B-isomorphism is defined in terms of a single mapping M for the entire RDF stream rather than, say, separate mappings for each timestamped graph.
Two RDF streams are isomorphic if there exists an RDF stream that is both B-isomorphic to one stream and S-isomorphic to the other stream.
RDF streams that are S-isomorphic are isomorphic.
RDF streams that are B-isomorphic are isomorphic.
Isomorphic RDF streams MUST have the same semantics. The semantics of RDF streams is affected by the result of applying window functions () as well as by entailment. Therefore, isomorphic RDF streams SHALL be indistinguishable, up to isomorphism, with respect to entailment (in any entailment regime), as well as with respect to the application of window functions.
A substream
S'
of an RDF stream S
is an RDF stream that is isomorphic to a
subsequence of S
.
There are several specializations of the substream relation which are useful in practice. These include the filter relation, where stream elements are selected based on satisfaction of some criterion, and the window relation, where a temporally contiguous portion of the stream is selected.
A window
S'
of an RDF stream S
is a substream of S
such that
if S'(i)
and S'(j)
are two elements of S'
and
S'(i) ≲ S'(j)
(i.e., S'(j)
covers S'(i)
), and
further if S'(i) ≲ S(k) ≲ S'(j)
for some element S(k)
of
S
, then S(k)
is an element of S'
.
Informally, a window is a temporally-contiguous selection from the original stream, without gaps.
In order to combine two RDF streams into one, without loss or gratuitous introduction of entailments, we define two relations, RDF stream merge and RDF stream union. These relations are inspired by the concepts of similar name for RDF graphs defined in [[RDF11-Concepts]].
RDF stream union is a trinary relation on RDF streams. Let S1
,
S2
, and S3
be RDF streams. We say S3
is an RDF
stream union of S1
and S2
if and only if the set of
elements of S3
is equal to the union of the sets of elements of S1
with S2
.
Union is the appropriate relation to consider when combining streams that are allowed to share blank nodes. Informally, they would be on the same RDF surface.
RDF stream merge is a trinary relation on RDF streams. Let S1
,
S2
, and S3
be RDF streams. We say S3
is an RDF
stream merge of S1
and S2
if and only if there exist
streams S4
, S5
, and S6
, with S4
isomorphic to S1
, S5
isomorphic to S2
,
S6
isomorphic to S3
, such that S4
and
S5
have no blank nodes in common, and S6
is the union of
S4
with S5
.
Merge is the appropriate relation to consider when joining streams that are considered to not share blank nodes. Informally, they would be on different RDF surfaces.
Given any three RDF streams, the determination of their satisfaction of the union or merge relation is a purely syntactic computation. That is, it is not necessary to consider entailments of the RDF streams or to be concerned with the values of literals.
The continuous operation of union or merge of two semi-infinite streams may not be computable, even when the operation is defined. This is because it may not be possible to know when an element of one stream might be received that needs to occur before the latest elements of the other stream. Computability of these continuous operations may be possible when additional information is available about the streams to be combined, e.g., the set of timestamp predicates used by each stream and the maximum latency of transmission. Within some RDF stream profiles, the union and merge operations may be continuously computable due to the profile constraints.
This section may be expanded with more subclasses if a need is identified.
A time-bounded-above RDF stream is an RDF Stream where for every timestamp predicate of the stream, there is a temporal entity in its range that bounds from above (is greater than or equal to) all timestamps of that predicate in the stream.
A time-bounded-below RDF stream is an RDF Stream where for every timestamp predicate of the stream, there is a temporal entity in its range that bounds from below (is less than or equal to) all timestamps of that predicate in the stream.
A time-bounded RDF stream is an RDF Stream that is time-bounded above and time-bounded below.
Consider the class of timestamp predicates whose associated poset of
temporal entities is pairwise bounded, i.e., has the property that every pair of
temporal entities is bounded, i.e., there exists a temporal entity in the poset that is
greater or equal to both of them and another temporal entity that is less or equal to both
of them. This is a fairly natural property to expect for partial orders on time plenums with "linear topology" (e.g.
[[OWL-TIME]]). However it does not hold in the case of branching time plenums (see http://www.ihmc.us/users/phayes/docs/timeCatalog.pdf), because there are incomparable
branches (called paths), which may be considered, e.g., as different worlds (in the sense of
Kripke frames), scenarios (planning usecase), or concurrent processes (process modelling).
It would be a useful property if the class of time-bounded RDF streams were closed under
stream merger and union, and this property would hold, under the current definition, in the
case of pairwise-bounded time plenums, because we could find bounds for the temporal entities
of each timestamp predicate by taking an upper bound of the pair of upper bounds from the
two streams, and similarly for the lower bounds. However, the closure property does not hold
in the case of a branching temporal topology under the above definition of time-bounded. To
achieve the closure property, we would have to allow a number of "upper bounds" for each
timestamp predicate, rather than requiring just one. For example,
Given two
sets, A and B, of entities in a partial order, we say that A bounds B from above iff there
is no element of B that is greater than any element of A, and for every element of B there
is some element of A that is greater than or equal to it.
A
time-bounded-above RDF stream is an RDF Stream where for every timestamp
predicate of the stream, there is a set of temporal entities in its range that
bounds from above all timestamps of that predicate in the stream.
The class of time-bounded RDF streams using timestamp predicates with pairwise-bounded time plenums is closed under stream merger and union.
A temporal-count-bounded RDF stream is an RDF stream where for each timestamp predicate of the stream, there are a finite number of temporal entities in the stream that are timestamps for that predicate.
The qualifier "temporal" has been added to this term to emphasize that it is temporal entities that are being counted, not timestamped graphs.
Given an RDF stream whose set of timestamp predicates with pairwise-bounded temporal entities, then if the stream is temporal-count-bounded it is also time-bounded, since the upper bound for each timestamp predicate can be taken as an upper bound of the (finite) set of its timestamps, and similarly for the lower bound. If the definition of "time-bounded" was changed as in the earlier Editor's Note, then every temporal-count-bounded RDF stream would be time-bounded.
Every temporal-count-bounded RDF stream using only timestamp predicates with pairwise-bounded time plenums is time-bounded.
The class of temporal-count-bounded RDF streams is closed under stream merger and union, since the sets of temporal entities for each timestamp predicate in the resulting stream are the union of the corresponding (finite) sets in the original streams, and so are finite.
A finite RDF stream is an RDF stream of finite length, i.e., with a finite number of elements in it.
Clearly, every finite RDF stream is temporal-count-bounded.
Every finite RDF stream using only pairwise-bounded time plenums is time-bounded. However, this is not the case for branching time plenums.
Clearly, the class of finite RDF streams is closed under stream merger and union.
A window function is a partial function from RDF streams to their windows that
preserves isomorphism. That is, if w
is a window function, with isomorphic
streams S1
and S2
in its domain, then w(S1)
is
isomorphic to w(S2)
.
A general window function is a window function that is a total function on RDF streams.
The term "window operator" is reserved for later use to return a sequence of windows.
The most common types of window functions in practice are time-based and count-based.
Because the time plenum for each timestamp predicate is partially ordered, we may define a temporal interval of a timestamp predicate to be an interval, in the usual sense for partial orders, within its time plenum.
Recall that intervals need not be bounded and need not be closed, and are specified in terms of two, one or zero inequality conditions based on the partial order or its induced strict order.
A general time-based window function
w
is a general window function specified by a finite set
wP
of timestamp predicates together with temporal intervals
wJ(P)
of each timestamp predicate P
in
wP
, such that for every stream S
, an element
S(i)
of S
is an element of w(S)
if and only if the
timestamp predicate P
of S(i)
is in P
and the
timestamp t
of S(i)
is contained in
wJ(P)
.
A time-based window function is the restriction of a general time-based window function to a subset of RDF streams.
The substream resulting from the application of a time-based window function is time-bounded.
A general temporal-count-based window function
w
is a general window function specified by a finite set
wP
of timestamp predicates together with semi-infinite temporal
intervals wJ(P)
of each timestamp predicate P
in
wP
with endpoints wT(P)
, and positive
integers wN(P)
, for each timestamp predicate P
in
wP
such that for every stream S
, an element
S(i)
of S
is an element of w(S)
if and only if the
timestamp predicate P
of S(i)
is in P
and
t
is the timestamp of S(i)
,T(S, P, w)
is the set of temporal entities that are timestamps for
elements of S
with timestamp predicate P
, belong to
wJ(P)
, and belong to the closed interval between
t
and wT(P)
, andT(S, P, w)
is less than or equal to
wN(P)
A temporal-count-based window function is the restriction of a general temporal-count-based window function to a subset of RDF streams.
The substream resulting from the application of a temporal-count-based window function is temporal-count-bounded.
Due to the potential for stream elements with incomparable or duplicate timestamps, the number of elements in the substream having a particular timestamp predicate is not guaranteed to be equal to the depth specified for the predicate by the temporal-count-based window.
Temporal-count-based window functions with future-facing orientation on timestamp predicates whose time plenum is not totally-ordered are not computable, because in general it is not possible to know, at any point in the reception of the stream, whether there are further elements of the stream that would be selected by the temporal-count-based window function.
Applications that require a substream with an exact number N
of elements for
a specified timestamp predicate might apply a temporal-count-based window function with
N
for the count of temporal entities, and then randomly discard extra
elements, according to some criterion, e.g., extreme elements (maximal or minimal,
depending on the orientation of the counting). However, this extra step causes the process
to be nondeterministic, and hence does not correspond to a function. If elements are
discarded in a nonrandom fashion, e.g., based on their order in the stream sequence, then
this would be a function, but would not preserve isomorphism, and so would not be a window
function. The issue of obtaining a window function that returns an exact number of
elements (for a particular predicate) is handled in the next section, where we define the
concept of window relation, and use it to define an element-count-based window relation.
When restricted to certain kinds of RDF streams, element-count-based window relations are
functional so element-count-based window functions can be defined on such subsets. This
and similar considerations, of importance to implementations, motivate the RDF Stream profiles as subsets of RDF streams.
A window relation is a binary relation on RDF streams (a relation having an
extension which is a set of pairs of RDF streams) such that the second element in the pair
is a window of the first element and preserves isomorphism. That is, if <S1,
S2>
is a member of the extension of a window relation W
, and
S3
and S4
are isomorphic to S1
and
S2
, resp., then <S3, S4>
is also a member of the
extension of W
.
A length-based window relation
W
is a window relation specified by a set of streams
WS
, a finite set WP
of timestamp
predicates together with the following parameters for each timestamp predicate
p
in WP
:
WJ(P)
of timestamp
predicate P
(the interval of P
);WT(P)
which is the finite endpoint of
WJ(P)
(the temporal reference of P
);WN(P)
(the length for
P
)S
be an RDF stream in WS
with window
S'
. Define T(S, P, W)
to be the set of temporal entities that
are timestamps for elements of S
with timestamp predicate P
and
belong to WJ(P)
, and T(S', P)
to be the set of
temporal entities that are timestamps for elements of S'
with timestamp
predicate P
. The pair <S, S'>
is a member of the extension
of W
if and only if the cardinality of T(S', P)
is equal to the
minimum of WN(P)
and the cardinality of the set T(S, P,
W)
and for each element S'(i)
of S'
P
of S'(i)
is in
WP
, andt
of S'(i)
is in
WJ(P)
.A length-based window function
W
on domain WS
is a length-based window relation
where any member <S, S'>
of its extension are such that S
is in WS
and W
defines a total function on
WS
.
The names "element-count-bounded window relation" and "element-count-bounded window function" have been proposed, as a replacement of "length-bounded ...". This nomenclature depends on the adoption of "element" as the term for the individual timestamped graphs in a stream.
this example could be integrated to the main text body
Beyond time instants: intervals & more
Usign the previously described model, intervals can be specified for a graph in the following way: Given p1 and p2 representing start and end time predicates, then
(g,p1,t1)
and(g,p2,t2)
denote that g is defined in an interval [t1,t2]. As an example::g_1, :startsAt, "2015-06-18T12:00:00"^^xsd:dateTime :g_1, :endsAt, "2015-06-18T13:00:00"^^xsd:dateTime
Or even:
:g_2 :validBetween [:startsAt "2015-06-18T12:00:00"^^xsd:dateTime; :endsAt "2015-06-18T13:00:00"^^xsd:dateTime]
The semantics of a timestamped graph is defined in terms of its semantics as an RDF Dataset. In particular, the designation of a particular triple in the default graph as the timestamp triple has no effect on its semantics.
The semantics of timestamped graphs, and consequently of RDF streams, is based on the semantics formalized in [[RDF11-Datasets]] in the case that each named graph defines its own context.
The following terms are used in the sense of [[RDF11-MT]]: entailment regime, E-interpretation, blank node, universe, named graph pair, RDF graph, E-entails, default graph.
An RSP interpretation
I
with respect to an entailment regime E
is an E-interpretation
extended to named graphs, timestamped graphs, RDF datasets, and RDF streams as follows:
A
from blank nodes to the universe IR
and a
named graph pair ng
= <n, G>
, [I+A](ng)
is
true if and only if [I+A](n)
is an RDF graph that E-entails
G
;TSG
= < ng, DG>
, where
DG
is the default graph and ng
is the named graph pair of
TSG
,and a mapping A
from blank nodes to the universe
IR
, [I+A](TSG)
is true if and only if [I+A](DG)
is true and [I+A](ng)
is true;I(TSG)
true if and only if there exisits a mapping A
from
blank nodes to the universe IR
such that [I+A](TSG) is true.D
= < DG, NG>
, where DG
is the default graph and NG
is the set of named graph pairs of
D
, I(D)
is true if there exists a mapping A
from blank nodes to the universe IR
such that [I+A](DG)
is
true and [I+A](ng)
is true for every ng
in
NG
;I(D)
is false otherwise.S
, I(S) is true if and only if if there exists a
mapping A
from blank nodes to the universe IR
such that for
every element S(i)
of S
, i ≥ 1
,
[I+A](S(i))
is true.I
E-satisfies a graph, named graph
pair, timestamped graph, dataset, or stream X
(or satisfies A
w.r.t the E-entailment regime) when I(X)
is true.
Following standard terminology, we say that a graph, named graph, timestamped graph,
dataset, or stream X
RSP-E-entails a graph, named graph, timestamped graph,
dataset, or stream Y
if and only if for every RSP interpretation I
with respect to E-entailment, I
E-satisfies Y
whenever
I
E-satisfies X
.
The "RSP" prefix in "RSP-E-entails" may be dropped when neither antecedent nor consequent is an RDF dataset or named graph, as in that case there is no possibility of alternate dataset semantics.
It should be straightforward to prove that isomorphic RDF streams simply entail each other, and hence are logically equivalent under simple entailment. This should also hold for other standard entailment regimes, and perhaps should be required for all RSP entailment regimes.
The notion of RSP-E-entailment is defined here so that it may be used to
support the definition of query semantics under various entailment regimes in the [[RSP-QL
Queries]] document, including simple entailment. A choice was made regarding the semantics
of named graph pairs (i.e., [I+A](ng)
is true if and only if
[I+A](n)
is an RDF graph that E-entails G
) that affects the
semantics of timestamped graphs, datasets, and streams. It remains to be seen if this choice
supports query semantics in a manner that meets the needs of the RSP-QL community. In
particular, it imposes constraints on the denotation of the name of a named graph pair which
may be inconsistent with the domain of a predicate that might be considered for use as a
timestamp predicate (e.g., SSN predicate ssn:observationSamplingTime
).
It is possible to restrict the abstract syntax for a class of RDF streams. This is often done in order to facilitate the efficient implementation of certain operations and queries or to promote more efficient representation. Each such restriction constitutes an RDF stream profile.
The profiles defined in this document fall into two categories: time-series profiles and linked-list profiles. Within each category there is a least-restrictive profile and a number of subprofiles which apply additional restrictions to it.
This section describes four profiles which are defined through restrictions on the default graphs of the stream's timestamped graph elements or on the relation between timestamp values:
The RDF Stream Time-Series profile is designed to support high-volume, low-latency window operations and queries that depend on full knowledge of timestamps.
This motivational paragraph needs some work - the above is a place holder.
An RDF time series is an RDF stream that satisfies the following properties:
If some property (e.g., in the RSP-QL namespace) is defined as a
subproperty of prov:generatedAtTime
, then this can be substituted in Example 4, which will then serve as an example of a
time series. Alternatively, the definition could be changed so that the only requirement
is that the timestamps that occur in the stream belong to xsd:dateTime.
The set of RDF time series is closed under RDF stream merge and union on time series that use the same timestamp predicate.
An "RDF distinct time series" is an RDF time series such that no two elements in the time series have the same timestamp.
An RDF distinct time series has a unique sequential order - it is S-isomorphic only to itself.
The merge or union of RDF distinct time series is always defined but is not necessarily an RDF distinct time series, even if the operation is restricted to time series that use the same timestamp predicate, due to the possibility of duplication of timestamp. However, the merge or union of RDF distinct time series that use the same timestamp predicate is always an RDF time series.
The restriction of element-count-based window relations to distinct time series results in functional relations. This enables the definition of element-count-based window functions for distinct time series. Further, the element-count-based window functions are always computable. However, the time-based window functions are not necessarily computable unless there is a finite precision to the timestamps, as can be seen from the Zeno's paradox example @@@(this example hasn't been written up yet, but is mentioned elsewhere).
There is going to be a lot more to talk about for RDF time series relative to queries, but in this document we don't have those definitions.
The restriction of timestamps in the regular time series profile allows the timestamp to be represented concisely as an integer, provided the spacing is provided elsewhere, e.g., in metadata.
@@@motivate this profile


|
OpenM++ runtime library (libopenm)
|
OpenM++: empty implementation of message passing library. More...
Go to the source code of this file.
Classes | |
| struct | openm::EmptyPackedAdapter |
| pack and unpack adapter for metadata table db rows (empty implementation). More... | |
| class | openm::MsgEmptyExec |
| message passing main class. More... | |
| class | openm::MsgEmptySendBase |
| base class for non-blocking send (empty implementation) More... | |
| class | openm::MsgEmptySendArray |
| non-blocking send of value array (empty implementation) More... | |
| class | openm::MsgEmptySendPacked |
| non-blocking send of packed data (empty implementation) More... | |
| class | openm::MsgEmptyRecvArray |
| non-blocking receive of value array (empty implementation) More... | |
| class | openm::MsgEmptyRecvPacked |
| non-blocking receive of packed data (empty implementation) More... | |
Namespaces | |
| openm | |
| openM++ namespace | |
OpenM++: empty implementation of message passing library.


This package provides the timing functions 'tic' and 'toc' that can be nested. One can record all timings while a complex script is running, and examine the values later. It is also possible to instrument the timing calls with custom callbacks. In addition, this package provides class 'Stack', implemented as a vector, and class 'List', implemented as a list, both of which support operations 'push', 'pop', 'first', 'last' and 'clear'.
| Version: | 1.0 |
| Depends: | R (≥ 3.0.3), methods |
| Published: | 2014-06-17 |
| Author: | Sergei Izrailev |
| Maintainer: | Sergei Izrailev <sizrailev at collective.com> |
| License: | Apache License (== 2.0) | file LICENSE |
| Copyright: | Copyright (C) Collective, Inc. | file inst/COPYRIGHTS tictoc copyright details |
| URL: | http://github.com/collectivemedia/tictoc |
| NeedsCompilation: | no |
| Materials: | README NEWS |
| CRAN checks: | tictoc results |
| Reference manual: | tictoc.pdf |
| Package source: | tictoc_1.0.tar.gz |
| Windows binaries: | r-devel: tictoc_1.0.zip, r-release: tictoc_1.0.zip, r-oldrel: tictoc_1.0.zip |
| OS X binaries: | r-release: tictoc_1.0.tgz, r-oldrel: tictoc_1.0.tgz |
| Reverse depends: | spFSR |
| Reverse imports: | ExPanDaR, frite, mafs, pingers, SWMPr |
Please use the canonical form https://CRAN.R-project.org/package=tictoc to link to this page.


I have Experiences in a good amount of stuff. I am currently getting a good learning experience in the Tech field working on computers and chromebooks. I also have experiences in stuff like band where I can currently know how to play the Trumpet and the Baritone. I am a part of the FTC (7247) and FRC (5837) robotics team for East and West and I am currently a part of the Super Smash Bros Ultimate eSports team (And for those who care, I play King Dedede the most).
Photos
Photos that are related to what I'm experienced in.


| rustfare | R Documentation |
The rustfare package pools together tools for searching, extracting, and formatting welfare data on Russian Federation from different data providers. The rustfare functions are named according to data provider or the data set. Currently there data available from: Rosstat Regional Statistics, OECD, Quality of Governance -institute and World Bank
rustfare: toolbox for R language for open welfare data from Russian Federation
| Package: | rustfare |
| Type: | Package |
| Version: | See sessionInfo() or DESCRIPTION file |
| Date: | 2013 |
| License: | MIT |
| LazyLoad: | yes |
Markus Kainu <markuskainu(at)gmail.com> http://markuskainu.fi/rustfare https://github.com/muuankarski/rustfare
# library(rustfare)


Don't use ls | grep. Use a glob or a for loop with a condition to allow non-alphanumeric filenames.
ls /directory | grep mystring
or
rm $(ls | grep -v '\.c$')
ls /directory/*mystring*
or
# BASH
shopt -s extglob
rm -- !(*.c)
# POSIX
for f in ./*
do
case $f in
*.c) true;;
*) rm "$f";;
esac
done
Parsing ls is generally a bad idea because the output is fragile and human readable. To better handle non-alphanumeric filenames, use a glob. If you need more advanced matching than a glob can provide, use a for
loop.
ls
has sorting options that are tricky to get right with other commands. If a specific order of files is needed, ls \<sort options> | grep might be the best alternative.


404 Errors
WAIT,DON'T LEAVE YET!
- Use your browser's back button to return to the page that brought you here.
- Enter a search term below.
- Check out stories about watches,
street style,
suits,
hair styles,
men's health,
and men's style blogs. - See below for the latest articles on Details.com.


|
|
Pantheios comes with several pre-written stock back-end libraries, which cover most common needs for diagnostic logging. They also serve as good examples of how to write a custom back-end.
Modules | |
| Pantheios Local/Remote Split Back-end | |
| Back-end library that splits the emission of log statements, writing to local and/or remote back-ends that are independently filtered. | |
| Pantheios N Stock Back-end | |
| Back-end library that splits output to N back-ends. | |
| Pantheios ACE Stock Back-end | |
| Back-end library built on top of the diagnostic logging facilities of the Adaptive Communications Environment (ACE). | |
| Pantheios COM Error Object Stock Back-end | |
| Back-end library that sets the calling threads's COM error object. | |
| Pantheios Console Stock Back-end | |
| Back-end library that outputs to the console, providing colour-coding options as available on the given platform. | |
| Pantheios Fail Stock Back-end | |
| Stub back-end library that fails its initialisation. | |
| Pantheios file Stock Back-end | |
| Back-end library that outputs to a file. | |
| Pantheios fprintf() Stock Back-end | |
Back-end library that writes to the standard output or error stream via fprintf() . | |
| Pantheios NULL Stock Back-end | |
| Stub back-end library that does no emission. | |
| Pantheios speech Stock Back-end | |
| Back-end library that outputs as speech. | |
| Pantheios UNIX SysLog Stock Back-end | |
| Back-end library built on top of the UNIX syslog API. | |
| Pantheios Test Stock Back-end | |
| Stub back-end library that does no emission. | |
| Pantheios Windows Console Stock Back-end | |
| Back-end library that outputs to the Windows console, colour-coding based on severity level. | |
| Pantheios Windows Debugger Stock Back-end | |
| Back-end library that outputs to the Windows debugger. | |
| Pantheios Windows EventLog Stock Back-end | |
| Back-end library that writes to the Windows event log. | |
| Pantheios Windows Message Box Stock Back-end | |
| Back-end library that writes to the Windows event log. | |
| Pantheios Windows-SysLog Stock Back-end | |
| Back-end library that provides a custom implementation of the SysLog-protocol for Windows. |
|
|
|
| pantheios Library documentation © Matthew Wilson & Synesis Software, 2006-2011 |


◆ PartialVector3()
| BrawlLib.Internal.PartialVector3.PartialVector3 |
( |
float? |
x, |
|
|
float? |
y, |
|
|
float? |
z |
|
) |
| |
|
inline |
17 {
21 }
float? _z
Definition: Vector3.cs:14
float? _y
Definition: Vector3.cs:14
float? _x
Definition: Vector3.cs:14
◆ operator PartialVector3()
32 {
34 }
PartialVector3(float? x, float? y, float? z)
Definition: Vector3.cs:16
◆ operator Vector3()
24 {
25 return new Vector3(
26 v._x ?? throw new Exception("Cannot cast to Vector3 (X value is missing)"),
27 v._y ?? throw new Exception("Cannot cast to Vector3 (Y value is missing)"),
28 v._z ?? throw new Exception("Cannot cast to Vector3 (Z value is missing)"));
29 }
◆ _x
| float? BrawlLib.Internal.PartialVector3._x |
◆ _y
| float? BrawlLib.Internal.PartialVector3._y |
◆ _z
| float? BrawlLib.Internal.PartialVector3._z |
The documentation for this struct was generated from the following file:
- BrawlLib/Internal/Vector3.cs


Pronounced [ di - gee - tron - icks ]
DGtronicz® is a micro-enterprise in the industry of Information & Communications Technology (ICT). This ICT Consultancy, based in Barbados and founded in 2012, serves both residential and commercial clients with an emphasis on service excellence at affordable prices.
Services for small businesses
including but not limited to:
Services for individuals & homeowners
including but not limited to:
Reach us via WhatsApp
Social Media Pages
Follow us on Instagram
Follow us on LinkedIn
Like & Follow us on Facebook


The button below has been clicked {{counter$ | async}} time(s).
The button below has not yet been clicked.
Click me!


Environment Conditions
Explore the sub-topic areas below to learn more about environmental oversight of Mount Milligan, including project-specific conditions, inspections and actions.
- {{subtopic.name}} {{subtopic.conditions.length}} {{subtopic.name}} {{subtopic.conditions.length}}


This query demonstrates that SPARQL-Generate can use a RDF Dataset to parametrize the generation of RDF. Check out below what the default graph of the Dataset contains.
The general structure of a SPARQL-Generate query is as follows:
PREFIX declarations -- same as SPARQL 1.1 FROM and FROM NAMED clauses -- same as SPARQL 1.1 GENERATE template -- replaces and extends SPARQL 1.1 CONSTRUCT ITERATOR, SOURCE, BIND clauses -- see below WHERE clause -- same as SPARQL 1.1 Solution modifiers -- group by, order by, limit, offset,... same as SPARQL 1.1
To put it simply, the execution of a SPARQL-Generate is defined as follows:


Home
About Us
Services
Contact Us
Here are list of the services we provide :
Full House cleaning
Laundary
Partial house cleaning
Sofa & Couch cleaning
Enter your cleaning request serivce details here
Choose your service
Full house cleaning 8000 Rwf
Laundry 5000 Rwf
Partial cleaning 4500 Rwf
Choose your most cleaning materials
Glasses 500 Rwf
Tile 400 Rwf
Texture 1000 Rwf
Choose your Task
cleaning
Laundry
Number of prefferable workers
Name
Location
Phone Number
Checkout


Welcome to Annual Lecture 2018.
Details about the events.
Creativity of the NU Vividha Art Club
Photo gallery of NU Instills Photography Club.
Research works done by the students and faculties of NU


Table of Contents
| Final Moves
Prev:
Changing the Player Character
Next:
Some Output Issues
Part VI: Final Moves
This part deals with a few miscellaneous topics and wraps up the manual.
Some Output and Input Issues
Utility Functions
Lists and Listers
The Web UI
Extensions
Exercises & Samples
Feedback
Conclusion
Change Log
Index
adv3Lite Library Manual
Table of Contents
| Final Moves
Prev:
Changing the Player Character
Next:
Some Output Issues


Monday Night Football in Mexico: Texans-Raiders face off in return
The Texans and Raiders face off in Week 11 of Monday Night Football in the NFL's return to Mexico. It will be the second regular-season game to take place at Mexico City's Estadio Azteca.
The NFL has a storied history in Mexico:
The first NFL regular-season game played outside of the United States was on Oct. 2, 2005, when the Cardinals won 31-14 over the 49ers at Estadio Azteca in front of 103,467 people.
The league's two most-attended games were played at Estadio Azteca, both in the preseason. On Aug. 15, 1994, the Cowboys and Oilers played in front of 112,376 people, and on Aug. 17, 1998, 106,424 fans watched the Cowboys and Patriots play.
Approximately 16.88 million households make up Mexico's TV viewing population, about 15 percent the size of the U.S. TV market and roughly equivalent to the combined size of the top three markets in this country -- New York, Los Angeles and Chicago.
Week 11's best fantasy football free-agent finds
Prior to the season, I was among those who believed that the soundest strategy leading into your draft if you owned one of the top three picks was to go with a wide receiver (my ranks: Antonio Brown, Julio Jones and Odell Beckham Jr. in that order). Why? Because running backs are -- generally speaking -- less predictable for fantasy purposes.
However, with 10 regular-season Sundays in the books and just three more until we reach the ESPN Fantasy postseason, many of you who have already punched your playoff ticket -- or come close -- have likely done so because of a workhorse running back. Those aren't readily available on the waiver wire, but today's column will include a list of handcuffs to the top-scoring backs who should be owned in all leagues (excluding those who are already owned in more than 50 percent of leagues). Beyond that, we'll have our usual assortment of selections
Note: All players on this list are owned in less than 50 percent of leagues on ESPN.com.
England vs Spain match report: Isco's last-minute goal spoils Gareth Southgate's perfect audition
Nothing is easy, nothing is smooth, when it comes to the England national team. Gareth Southgate had that fact burned into him 20 years ago but this match, and especially the last five minutes of it, formed another helpful reminder.
This was very nearly the perfect evening for Southgate, in the fourth and final match of his audition for the full-time job. Normal time was nearly done and England were 2-0 up against Spain, hoping to see out what would have been a brilliant win, deserved and controlled, a win that would have shown that England can now beat almost anyone.
Read more here.


Which of these is a true statement about the worst-case time for operations on heaps?
Insert works by putting the new element at the end of the array, and moving it up the tree as appropriate.
So its worst-case cost is proportional to the depth of the tree.
Remove works swapping the element to remove with the one at the end of the array. Then move that moved item up or down the tree, as appropriate.
So its worst-case cost is proportional to the depth of the tree.


It's a fine way to start a day, don't you think?
There are many ways to greet a person, but the words are not so important as the act of greeting itself.
There is nothing finer than a hearty welcome from one's fellow man.
Although a thick and juicy hamburger with bacon and mushrooms runs a close second.


Delete Proposal
Description:
Details:
Date Created:
Warning!
You are about to delete this Proposal. Continue with the deletion?
Confirm
Cancel


Hey there,
You have been invited to create a user on {{ .SiteURL }}. Follow this link to accept the invite:
Copyright © 2019 Corina Patings


26.1 [disability-exercise]Go through Turing’s list of alleged “disabilities” of machines, identifying which have been achieved, which are achievable in principle by a program, and which are still problematic because they require conscious mental states.
26.2 Find and analyze an account in the popular media of one or more of the arguments to the effect that AI is impossible.
26.3 Attempt to write definitions of the terms “intelligence,” “thinking,” and “consciousness.” Suggest some possible objections to your definitions.
26.4 Does a refutation of the Chinese room argument necessarily prove that appropriately programmed computers have mental states? Does an acceptance of the argument necessarily mean that computers cannot have mental states?
26.5 [brain-prosthesis-exercise]In the brain replacement argument, it is important to be able to restore the subject’s brain to normal, such that its external behavior is as it would have been if the operation had not taken place. Can the skeptic reasonably object that this would require updating those neurophysiological properties of the neurons relating to conscious experience, as distinct from those involved in the functional behavior of the neurons?
26.6 Suppose that a Prolog program containing many clauses about the rules of British citizenship is compiled and run on an ordinary computer. Analyze the “brain states” of the computer under wide and narrow content.
26.7 Alan Perlis [@Perlis:1982] wrote, “A year spent in artificial intelligence is enough to make one believe in God”. He also wrote, in a letter to Philip Davis, that one of the central dreams of computer science is that “through the performance of computers and their programs we will remove all doubt that there is only a chemical distinction between the living and nonliving world.” To what extent does the progress made so far in artificial intelligence shed light on these issues? Suppose that at some future date, the AI endeavor has been completely successful; that is, we have build intelligent agents capable of carrying out any human cognitive task at human levels of ability. To what extent would that shed light on these issues?
26.8 Compare the social impact of artificial intelligence in the last fifty years with the social impact of the introduction of electric appliances and the internal combustion engine in the fifty years between 1890 and 1940.
26.9 I. J. Good claims that intelligence is the most important quality, and that building ultraintelligent machines will change everything. A sentient cheetah counters that “Actually speed is more important; if we could build ultrafast machines, that would change everything,” and a sentient elephant claims “You’re both wrong; what we need is ultrastrong machines.” What do you think of these arguments?
26.10 Analyze the potential threats from AI technology to society. What threats are most serious, and how might they be combated? How do they compare to the potential benefits?
26.11 How do the potential threats from AI technology compare with those from other computer science technologies, and to bio-, nano-, and nuclear technologies?
26.12 Some critics object that AI is impossible, while others object that it is too possible and that ultraintelligent machines pose a threat. Which of these objections do you think is more likely? Would it be a contradiction for someone to hold both positions?


"Hello! Revellers"
fesoroxx season, wild sound 2021
Fesoroxx Wild Sound is a concert held yearly in different countries all of the world, it features various performing acts, artistes and musical plays.
Please contact us for further enquiries about Fesoroxx 2021
wildsound@fesoroxx.com


{% endblock %}
{% block footer_mission %}
The flyingcracker staff is dedicated to providing you with recipes for high quality libations. Our selection criteria is simple: All drinks submitted must pass a rigorous multiple session taste test before they can be added. If we find a drink sufficiently delectable it gets added. If we yawn, or like the taste but never bother to mix it again, the drink is not added. If you have a suggestion for our drink list please email us: graham at flyingcracker dot com. Please drink responsibly.
{% endblock %}


Pat's Salmon Cookies Sales
home
locations
menu
swag
The hottest new cookie with your coffee!
Add a New Store
Name of New Store Location
Min Daily Customer Average
Max Daily Customer Average
Average Cookie Sale Per Hour
Submit New Store


Authorised Activity Type Defining Diagram
"Activity Type" that an "Agent" has been authorised to perform by another "Agent".
This could be very broad: 'General Surgical Duties', or narrower: 'Cardiac Surgical Duties'.
It could be a hospital's authorisation to a clinician that, although generally authorised to perform all surgical duties, the hospital only authorises the clinician to perform cardiac surgical procedures.
The relationship to "Activity Type" via "Activity Type Permission" and its subtypes, allows for selective inclusion and exclusion of Authorise Activities.
Supertypes:
Authorised Agent Activity
Authorised Agent Defining Diagram
"Agent" whose actions are subject to another's authority and control.
The type of control would include permissions (may do), obligations (must do) and interdictions (must not do).
An "Agent" who invests authority in another shares some liability for the actions of those to whom it gives authority.
An example of an "Authorised Agent " would be Dr. Smithers given the authority by the NHS XYZ Trust to run the Medical Clinical Directorate.
Associations From:
| Only One |
agent for |
Zero, One or Many |
Authorised Agent Activity |
Associations To:
| Zero, One or Many |
at some specified |
Zero, One or Many |
Location |
| Zero, One or Many |
authority |
Only One |
Agent |
| Zero, One or Many |
for some |
One or Many |
Subject Characteristic Type |
| Zero, One or Many |
for some |
Zero, One or Many |
Subject Characteristic Type |
| Zero, One or Many |
from |
Only One |
Timepoint |
| Zero, One or Many |
to |
Zero or One |
Timepoint |
Supertypes:
Agent
Subtype Partitions:
AA/nature
Agent By Devolvement
Agent By Licence
AA/origin
Derived Agent
Principal Agent
Authorised Agent Activity Defining Diagram
"Activity Type for Agent" that is subject to some type of authorisation or external control.
Such control can be interdictions, permissions and exceptions (including "Activity State Types") to one or many Activity Types.
Associations From:
| Zero, One or Many |
specified by |
Only One |
Activity Specification |
Associations To:
| Zero, One or Many |
agent for |
Only One |
Authorised Agent |
| Zero, One or Many |
end |
Only One |
Timepoint |
| Zero, One or Many |
end |
Zero or One |
Timepoint |
| Zero, One or Many |
start |
Only One |
Timepoint |
| Zero, One or Many |
start |
Zero or One |
Timepoint |
Supertypes:
Agent's Activity Type
Subtype Partitions:
AAA/essential type
Authorised Activity Type
Authority To Authorise
Authority To Authorise Defining Diagram
Authority held by one "Agent" to authorise other "Agents" to perform certain "Activity Types".
The General Medical Council has the "Authority to Authorise" medical staff to perform various kinds of medical duties. It does not have the authority to perform these duties itself.
Supertypes:
Authorised Agent Activity


This is your one-stop shop for all of the smallwares, parts and supplies that you need to run your restaurant
As part of this program, you will also get:
Please see below for your Tundra customer service and account team contacts. We are here to take care of you!
Order Entry, Parts Research, and Product Returns
Si hablamos Espanol. Porfavor pregunte por un representante que habla Espanol cuando llame.
P:<PHONE_NUMBER> press #2


Pulling Images From Private Docker Registries on GitLab CI
Want to use an image from a private Docker registry as the base for GitLab Runner’s Docker executor?
ECR example:
<AWS_ACCOUNT_ID>.dkr.ecr.<AWS_REGION>.amazonaws.com/<NAMESPACE>:<TAG>
Full job:
test:api:dev:
stage: test
image: <AWS_ACCOUNT_ID>.dkr.ecr.<AWS_REGION>.amazonaws.com/<NAMESPACE>:<TAG>
services:
- postgres:latest
- redis:latest
variables:
POSTGRES_DB: data_api
POSTGRES_USER: runner
POSTGRES_PASSWORD: runner
DATABASE_URL: postgres://runner:runner@postgres:5432/data_api
script:
- cd api
- export DEBUG=1
- export ENVIRONMENT=dev
- export CELERY_BROKER_URL=redis://redis
- export CELERY_RESULT_BACKEND=redis://redis
- python -m pytest -p no:warnings .
- flake8 .
- black --exclude="migrations|env" --check .
- isort --skip=migrations --skip=env --check-only
- export DEBUG=0
- export ENVIRONMENT=prod
- python manage.py check --deploy --fail-level=WARNING
Assuming the image exists on the registry, you can set the DOCKER_AUTH_CONFIG
variable within your project’s Settings > CI/CD page:
"auths": {
"registry.example.com:5000": {
"auth": "TBD"
}
}
The value of auth
is a base64-encoded version of your username and password that you use to authenticate into the registry:
$ echo -n "my_username:my_password" | base64
Continuing with the ECR example, you can generate a password using the following command:
$ docker run --rm \
-e AWS_ACCESS_KEY_ID=<AWS_ACCESS_KEY_ID> \
-e AWS_SECRET_ACCESS_KEY=<AWS_SECRET_ACCESS_KEY> \
amazon/aws-cli ecr get-login-password \
--region <AWS_REGION>
To test, run:
$ docker login -u AWS -p <GENERATED_PASSWORD> <AWS_ACCOUNT_ID>.dkr.ecr.<AWS_REGION>.amazonaws.com
Login Succeeded
Now, add the DOCKER_AUTH_CONFIG
variable to your project’s Settings > CI/CD page:
"auths": {
"registry.example.com:5000": {
"auth": "<GENERATED_PASSWORD>"
}
}
Test out your build. You should see something similar to the following in your logs, indicating that the login was successful:
Authenticating with credentials from $DOCKER_AUTH_CONFIG
Pulling docker image [MASKED].dkr.ecr.us-east-1.amazonaws.com/api:latest ...
Unfortunately, we’re not done yet since the generated password/token from the get-login-password command is only valid for 12 hours. So, we need to dynamically update the DOCKER_AUTH_CONFIG
variable with a new password. We can set up a new job for this:
build:aws_auth:
stage: build
services:
- docker:dind
image: docker:stable
variables:
DOCKER_DRIVER: overlay2
DOCKER_BUILDKIT: 1
script:
- export AWS_ACCESS_KEY_ID=$AWS_ACCESS_KEY_ID
- export AWS_SECRET_ACCESS_KEY=$AWS_SECRET_ACCESS_KEY
- export AWS_SECRET_ACCESS_KEY=$AWS_SECRET_ACCESS_KEY
- export AWS_DEFAULT_REGION=$AWS_DEFAULT_REGION
- export TOKEN=$TOKEN
- export PROJECT_ID=$PROJECT_ID
- apk add --no-cache curl jq bash
- chmod +x ./aws_auth.sh
- bash ./aws_auth.sh
Here, after exporting the appropriate environment variables (so we can access them in the aws_auth.sh script), we installed the appropriate dependencies, and then ran the aws_auth.sh script.
aws_auth.sh:
#!/bin/sh
set -e
AWS_PASSWORD=$(docker run --rm \
-e AWS_ACCESS_KEY_ID=$AWS_ACCESS_KEY_ID \
-e AWS_SECRET_ACCESS_KEY=$AWS_SECRET_ACCESS_KEY \
amazon/aws-cli ecr get-login-password \
--region $AWS_DEFAULT_REGION)
ENCODED=$(echo -n "AWS:$AWS_PASSWORD" | base64)
PAYLOAD=$( jq -n --arg userpass "$ENCODED" '{"auths": {"263993132376.dkr.ecr.us-east-1.amazonaws.com": {"auth": $userpass}}}' )
curl --request PUT --header "PRIVATE-TOKEN:$TOKEN" "https://gitlab.com/api/v4/projects/$PROJECT_ID/variables/DOCKER_AUTH_CONFIG" --form "value=$PAYLOAD"
What’s happening?
- We generated a new password from the
get-login-password
command and assigned it toAWS_PASSWORD
- We then base64 encoded the username and password and assigned it to
ENCODED
- We used jq to create the necessary JSON for the value of the
DOCKER_AUTH_CONFIG
variable - Finally, using a GitLab Personal access token we updated the
DOCKER_AUTH_CONFIG
variable
Make sure to add all variables you project’s Settings > CI/CD page.
Now, the DOCKER_AUTH_CONFIG
variable should be updated with a new password for each build.
That’s it!
–
Helpful Resources:
- GitLab Runner Issue Thread - Pull images from aws ecr or private registry
- GitLab Docs - Define an image from a private Container Registry


[view on github] v0.8.3
Cross-browser CSS3 transitions in JavaScript.
The idea behind Tram is to take the performance and flexibility of CSS transitions and define them in JavaScript - offering a more powerful, expressive API with auto-stopping, sequencing, and cross-browser fallbacks.
Tram currently depends on jQuery for a few reasons: (1) Per-element data API, (2) Cross-browser CSS getters/setters, and (3) scrollTop/Left offset helpers. Keep these features in mind when making custom jQuery builds or porting tram to your library.
Available on npm: npm install tram
Available on bower: bower install tram
File size:
45 kb
16 kb
4 kb
On first load, Tram will use feature detection to determine whether the browser supports CSS transitions. If yes, Tram will manage styles and trust the browser to handle the frame by frame animation. If no, Tram will set styles on each frame, using its own tweening engine powered by requestAnimationFrame and performance.now().
Please keep your arms and legs inside the tram at all times.
Tram can be loaded via AMD, CommonJS, browser globals, or all of the above (via UMD).
var tram = window.tram;
// or
var tram = require('tram');
Before you add a transition to an element, you must first wrap it with the tram()
method. This stores a Tram class instance in the element data, which is used for auto-stop and other state.
tram(element);
You may optionally save a reference to this instance, which may help performance for a large group of elements.
var myTram = tram(element); // optional
Each property must now be defined using the add()
method. This should feel very familiar to CSS3 transition shorthand: property-name duration easing-function delay
tram(element).add('opacity 500ms ease-out');
Once a transition is defined, it is stored in element data. You may override settings later, for example:
tram(element).add('opacity 2s'); // changed duration to 2 seconds
To begin a transition on your element, the start()
method is used.
tram(element).start({ opacity: 0.5 });
If you'd like to listen for the transition end event, use then()
and supply a function:
tram(element)
.start({ opacity: 0.5 })
.then(function () { console.log('done!') });
Sequencing is also available by using then()
. For example:
tram(element)
.start({ opacity: 0.5 })
.then({ opacity: 1 })
.then({ opacity: 0 });
Tram provides some virtual properties to help with CSS3 transforms.
tram(element)
.add('transform 1s ease-out-quint')
.start({ x: 100, rotate: 45 }); // aka: translateX(100px) rotate(45deg)
If you need to set style values right away, use the set()
method. This will stop any transitions, and immediately set the values.
tram(element).set({ x: 0, opacity: 1 });
Stopping a transition may be done using the stop()
method. This also happens automatically whenever start()
or set()
are called.
tram(element).stop('opacity'); // specific property
tram(element).stop({ opacity: true, x: true }); // multiple properties
tram(element).stop(); // stops all property transitions
That's about it. For more, check out the examples or refer to the docs below.
TODO document each method
Browser support for transitioning DOM properties is limited, so Tram attempts to cover the most common cross-browser properties, plus a few extras. This list was compiled using CSS animation specs here and here.
'color' // color
'background' // color
'outline-color' // color
'border-color' // color
'border-top-color' // color
'border-right-color' // color
'border-bottom-color' // color
'border-left-color' // color
'border-width' // length
'border-top-width' // length
'border-right-width' // length
'border-bottom-width' // length
'border-left-width' // length
'border-spacing' // length
'letter-spacing' // length
'margin' // length
'margin-top' // length
'margin-right' // length
'margin-bottom' // length
'margin-left' // length
'padding' // length
'padding-top' // length
'padding-right' // length
'padding-bottom' // length
'padding-left' // length
'outline-width' // length
'opacity' // number
'top' // length, percentage
'right' // length, percentage
'bottom' // length, percentage
'left' // length, percentage
'font-size' // length, percentage
'text-indent' // length, percentage
'word-spacing' // length, percentage
'width' // length, percentage
'min-width' // length, percentage
'max-width' // length, percentage
'height' // length, percentage
'min-height' // length, percentage
'max-height' // length, percentage
'line-height' // number, length, percentage
'transform' // (see transform info below)
'scroll-top' // number (tween-only)
'scroll-left' // number (tween-only)
// TODO - planned support
// 'background-position' // [x, y] length, percentage
// 'transform-origin' // [x, y] length, percentage
// 'clip' // [x, y, w, h] rectangle
// 'crop' // [x, y, w, h] rectangle
Note: dash-style
names are required for .add()
, but other methods like .start()
and .stop()
may use camelCase
.
TODO describe transform shortcuts w/ examples
'x' // length, percentage
'y' // length, percentage
'z' // length, percentage
'rotate' // angle
'rotateX' // angle
'rotateY' // angle
'rotateZ' // angle
'scale' // number
'scaleX' // number
'scaleY' // number
'scaleZ' // number
'skew' // angle
'skewX' // angle
'skewY' // angle
'perspective' // length
A useful site with demos of most of these is easings.net
// Defaults
'ease'
'ease-in'
'ease-out'
'ease-in-out'
'linear'
// Quad
'ease-in-quad'
'ease-out-quad'
'ease-in-out-quad'
// Cubic
'ease-in-cubic'
'ease-out-cubic'
'ease-in-out-cubic'
// Quart
'ease-in-quart'
'ease-out-quart'
'ease-in-out-quart'
// Quint
'ease-in-quint'
'ease-out-quint'
'ease-in-out-quint'
// Sine
'ease-in-sine'
'ease-out-sine'
'ease-in-out-sine'
// Expo
'ease-in-expo'
'ease-out-expo'
'ease-in-out-expo'
// Circ
'ease-in-circ'
'ease-out-circ'
'ease-in-out-circ'
// Back
'ease-in-back'
'ease-out-back'
'ease-in-out-back'
If you'd like to contribute to this project, please submit all pull requests to the dev
branch. Any pull requests sent to master
will be closed. This is mostly to offset the convenience of having various dist/* files available on the master branch.
Grunt CLI tools may be helpful. The following commands should start a watch script that concats source files on each save:
(from the root directory)npm install grunt -g
grunt
Once you're ready to send a pull request, please view test/suite.html
in your browser to confirm that all tests are passing.
Special thanks to the following open source authors + libraries.
@ded - https://github.com/ded/morpheus
@rstacruz - https://github.com/rstacruz/jquery.transit
@visionmedia - https://github.com/visionmedia/move.js
@jayferd - https://github.com/jayferd/pjs
This code may be freely distributed under the MIT license.
Open source under the BSD License.
Copyright © 2001 Robert Penner All rights reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.


Before Change
// I can get rid of the loop.
replace_with = {np.inf: HIGHS_CONST_INF, -np.inf: -HIGHS_CONST_INF}
for key, val in replace_with.items():
x[x == key] = val
return x
def _linprog_highs(lp, solver, time_limit=1, presolve=False, parallel=False,
disp = False, maxiter=None, autoscale=False,
After Change
def _replace_inf(x):
// Replace `np.inf` with CONST_INF
infs = (np.abs(x) == np.inf)
x[infs] = np.sign(x[infs])*CONST_INF
return x
def _linprog_highs(lp, solver, time_limit=1, presolve=False, parallel=False,


One
Half
Half
Third
Third
Third
Quater
Quater
Quater
Quater
Fifth
Fifth
Fifth
Fifth
Fifth
Quater
Quater
Quater
Quater
Third
Third
Third
Half
Half
One


Welcome to this modest little corner of the Internet! Here, you will find information about several Java programming projects that are used in various programming courses. In particular, networking is an important topic, and this server also provides running instances of the server components. When you implement client components, this provides a server that you can use for testing.
Project repositories
Smaller projects are collected together into a single, public repository: https://gitlab.fhnw.ch/bradley.richards/java-projects. Only the most important of those projects have web pages on this site. Explore the repository for other examples.
The most important projects on this site are:
- The web server itself. This site runs on the web server that we develop in class. Yes, it really works!
- The chat room. The project defines a text-based protocol, and you can implement clients to use this protocol. The server component is running on this server.
- The Inductive Learning Framework (ILF): a toolkit for people working with rule-based learning. This project also provides an example of using Java modules, in particular, detecting and loading modules at runtime.
Planned for next year is the Extensible Game Server, which will provide a live server component to test against (both for game clients and for AI players), and will also provide an example of a Service Oriented Architecture (SOA) and XML-based messaging.
For more information about individual projects, click on the menu entries above or on the right, or explore the project repositories.
Licensing
All source code is open source. Unless otherwise noted, the individual projects are licensed under the BSD 3-clause license. The one exception is FreeSudoku, which I took over from an earlier maintainer, and he chose to license it under the GPL.


Hi, FIRSTNAME
It was great to see you at the club night! You looked adorable dancing with DANCEPARTNER :). I am glad to see that you have decided to prioritise social events. Getting to know your colleagues in an informal venue is a great way to increase synergy.
Also, we all loved what you bought when it was your turn :). I've had white russians, and I've had black russians, but I've never had a FAVORITECOLOR russian before! You will simply have to give me the recipe later. I am glad you are using these events as an opportunity to exercise your imagination. For a good consultant, imagination is just as important as logic.
There are no more social events this week, but you'll have more opportunities for fun soon enough. Make sure you prioritize them, and see them as an opportunity to exercise your imagination :).
Benedetto Tornincasa
Human Relations
Senior Consultant / Haka Leader


JavaScript is disabled on your browser.
Skip navigation links
Overview
Package
Class
Use
Tree
Deprecated
Index
Help
Prev Letter
Next Letter
Frames
No Frames
All Classes
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
R
S
T
U
V
W
X
T
TEMPLATE
- Static variable in class org.sbolstandard.core2.
SystemsBiologyOntology
An entity that acts as the starting material for genetic production (
SBO:0000645
).
TERMINATOR
- Static variable in class org.sbolstandard.core2.
SequenceOntology
The sequence of DNA located either at the end of the transcript that causes RNA polymerase to terminate transcription (
SO:0000141
).
TopLevel
- Class in
org.sbolstandard.core2
Represents a TopLevel object in the SBOL data model.
TOPOLOGY_ATTRIBUTE
- Static variable in class org.sbolstandard.core2.
SequenceOntology
Attributes added to describe the different kinds of replicon.
toString()
- Method in enum org.sbolstandard.core2.
AccessType
toString()
- Method in class org.sbolstandard.core2.
Activity
toString()
- Method in enum org.sbolstandard.core2.
ActivityRoleType
toString()
- Method in class org.sbolstandard.core2.
Agent
toString()
- Method in class org.sbolstandard.core2.
Annotation
toString()
- Method in class org.sbolstandard.core2.
Association
toString()
- Method in class org.sbolstandard.core2.
Attachment
toString()
- Method in class org.sbolstandard.core2.
Collection
toString()
- Method in class org.sbolstandard.core2.
CombinatorialDerivation
toString()
- Method in class org.sbolstandard.core2.
Component
toString()
- Method in class org.sbolstandard.core2.
ComponentDefinition
toString()
- Method in class org.sbolstandard.core2.
ComponentInstance
toString()
- Method in class org.sbolstandard.core2.
Cut
toString()
- Method in enum org.sbolstandard.core2.
DirectionType
toString()
- Method in class org.sbolstandard.core2.
Experiment
toString()
- Method in class org.sbolstandard.core2.
ExperimentalData
toString()
- Method in class org.sbolstandard.core2.
FunctionalComponent
toString()
- Method in class org.sbolstandard.core2.
GenericLocation
toString()
- Method in class org.sbolstandard.core2.
GenericTopLevel
toString()
- Method in class org.sbolstandard.core2.
Identified
toString()
- Method in class org.sbolstandard.core2.
Implementation
toString()
- Method in class org.sbolstandard.core2.
Interaction
toString()
- Method in class org.sbolstandard.core2.
Location
toString()
- Method in class org.sbolstandard.core2.
MapsTo
toString()
- Method in class org.sbolstandard.core2.
Measure
toString()
- Method in class org.sbolstandard.core2.
Measured
toString()
- Method in class org.sbolstandard.core2.
Model
toString()
- Method in class org.sbolstandard.core2.
Module
toString()
- Method in class org.sbolstandard.core2.
ModuleDefinition
toString()
- Method in enum org.sbolstandard.core2.
OperatorType
toString()
- Method in enum org.sbolstandard.core2.
OrientationType
toString()
- Method in class org.sbolstandard.core2.
Participation
toString()
- Method in class org.sbolstandard.core2.
Plan
toString()
- Method in class org.sbolstandard.core2.
Range
toString()
- Method in enum org.sbolstandard.core2.
RefinementType
toString()
- Method in enum org.sbolstandard.core2.
RestrictionType
toString()
- Method in enum org.sbolstandard.core2.
RoleIntegrationType
toString()
- Method in class org.sbolstandard.core2.
SBOLDocument
toString()
- Method in class org.sbolstandard.core2.
Sequence
toString()
- Method in class org.sbolstandard.core2.
SequenceAnnotation
toString()
- Method in class org.sbolstandard.core2.
SequenceConstraint
toString()
- Method in enum org.sbolstandard.core2.
StrategyType
toString()
- Method in class org.sbolstandard.core2.
Usage
toString()
- Method in class org.sbolstandard.core2.
VariableComponent
toString()
- Method in class org.synbiohub.frontend.
IdentifiedMetadata
toString()
- Method in class org.synbiohub.frontend.
WebOfRegistriesData
TRANS
- Static variable in class org.sbolstandard.core2.
SystemsBiologyOntology
Positional relationship between entities on different sides, or strands (
SBO:0000415
).
TRANSAMINATION
- Static variable in class org.sbolstandard.core2.
SystemsBiologyOntology
The transfer of an amino group between two molecules (
SBO:0000403
).
TRANSCELLULAR_MEMBRANE_EFFLUX_REACTION
- Static variable in class org.sbolstandard.core2.
SystemsBiologyOntology
A transport reaction which results in the removal of the transported entity from the cell (
SBO:0000588
).
TRANSCELLULAR_MEMBRANE_INFLUX_REACTION
- Static variable in class org.sbolstandard.core2.
SystemsBiologyOntology
A transport reaction which results in the entry of the transported entity, into the cell (
SBO:0000587
).
TRANSCRIPTION
- Static variable in class org.sbolstandard.core2.
SystemsBiologyOntology
Process through which a DNA sequence is copied to produce a complementary RNA (
SBO:0000183
).
TRANSFER_OF_A_CHEMICAL_GROUP
- Static variable in class org.sbolstandard.core2.
SystemsBiologyOntology
Covalent reaction that results in the transfer of a chemical group from one molecule to another (
SBO:0000402
).
TRANSLATION
- Static variable in class org.sbolstandard.core2.
SystemsBiologyOntology
Process in which a polypeptide chain is produced from a messenger RNA (
SBO:0000184
).
TRANSPORT_REACTION
- Static variable in class org.sbolstandard.core2.
SystemsBiologyOntology
Movement of a physical entity without modification of the structure of the entity (
SBO:0000185
).
TURTLE
- Static variable in class org.sbolstandard.core2.
SBOLDocument
Constant representing TURTLE file format
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
R
S
T
U
V
W
X
Skip navigation links
Overview
Package
Class
Use
Tree
Deprecated
Index
Help
Prev Letter
Next Letter
Frames
No Frames
All Classes


--- layout: page weight: 0 title: Drupal navigation: show: true --- To send emails from Drupal using SendGrid, you may use the SMTP Authentication Support module or the Swift Mailer module depending on your needs. {% anchor h2 %} Using the SMTP Authentication Support Module {% endanchor %}
To use SendGrid with Drupal, use the SMTP Authentication Support module. Install a version of this module that is compatible with your version of Drupal.
Open your modules page, find the SMTP module, and configure it with the following settings:
To use the Swift Mailer module, install a version of this module that is compatible with your version of Drupal.
Configuration for this module is largely the same as above.


iOS & Web Backend Developer
Hi, my name is Alvaro Franco. I'm 17 and I've been an iOS Developer since I was 13. I love to write wellcrafted and beautiful code in Objective-C. I have several iOS classes such as AFSpritz and AFWunderlist. I started creating Web Services with PHP but now I'm having fun with Node.js.
I've been making iOS classes to contribute the community. Who knows, maybe you'll need to implement one of my classes in your awesome project! By the way, all of them are available on CocoaPods.
Copyright © 2013-2014 Alvaro Franco
Social networks
Do you want to contact me or say Hi? Take a look at my social profiles.


Change Log¶
1.0.1 (2020-01-31)¶
update from template-python
use poetry 1.0.x
1.0.0 (2019-09-01)¶
rework documentation build process (see mkdocs folder)
configure github page under master/docs
configure documentation site on pypi
add doc style on all function
standardize parameter name
fix dev documentation dependency
0.1.2 (2019-07-05)¶
Stable version flag
Remove alpha note
0.1.1 (2019-07-05)¶
Removed version due to configuration error.
0.1.0 (2019-07-05)¶
Added Project Management:
initial project structure based on jacebrowning/template-python
initial project configuration
follow Semantic Versioning
configure travis-ci
publish alpha version (not functional) on pypi
configure coverage
configure scrutinizer
remove pylint.ini to a simple .pylintrc (add ide support)
disable pylint bad-continuation (bug with pep8 formater)
declare extra dependency
configure black and isort
refactorise makefile poetry run
introduce flake8 as linter
Documentation:
replace mkdocs with pydoc-markdown
Code:
define ‘definition’ module to declare all common definiton of btree
define ‘utils’ module to declare few async function like afilter, amap
fix flake8 syntax error
fix mypy typing error
add basic test unit
fix typing declaration
complete code coverage


Table of Contents
Dbstl is a C++ STL style API that provides for Berkeley DB usage. It allows for the storage and retrieval of data/objects of any type using Berkeley DB databases, but with an interface that mimics that of C++ STL containers. Dbstl provides access to all of the functionality of Berkeley DB available via this STL-style API.
With proper configuration, dbstl is able to store/retrieve any complex data types. There is no need to perform repetitive marshalling and unmarshalling of data. Dbstl also properly manages the life-cycle of all Berkeley DB structures and objects. All example methods referred to in this chapter can be found in the StlAdvancedFeaturesExample class in the $DbSrc/examples/stl/StlAdvancedFeatures.cpp file, and you can build the example in $DbSrc/build_unix directory like this: make exstl_advancedfeatures, where DbSrc is the source directory for Berkeley DB.
Dbstl is composed of many container and iterator class templates. These containers and iterators correspond exactly to each container and iterator available in the C++ STL API, including identical sets of methods. This allows existing algorithms, functions and container-adapters for C++ STL to use dbstl containers through its standard iterators. This means that existing STL code can manipulate Berkeley DB databases. As a result, existing C++ STL code can very easily use dbstl to gain persistence and transaction guarantees.
Because dbstl uses C++ template technologies, its performance overhead is minimal.
The dbstl API performs almost equally to the C API, as
measured by two different implementations of the TPC-B
benchmark: ex_tpcb
and
exstl_tpcb
.
The degree to which dbstl is portable to a new platform is determined by whether Berkeley DB is available on the platform, as well as whether an appropriate C++ compiler is available on the platform.
For information on porting Berkeley DB to new platforms, see the Berkeley DB Porting Guide.
Almost all the advanced C++ template features are used in dbstl, including:
member function templates
member function template overloads
partial specialization
default template parameters.
For this reason, you need a standards-compatible C++ compiler to build dbstl. As of this writing, the following compilers are known to build dbstl successfully:
MSVC8
gcc3.4.4 and above
Intel C++ 9 and above
For *nix platforms, if you can successfully configure
your Berkeley DB build script with
--enable-stl
, then you should be
able to successfully build dbstl library and application
code using it.
Besides its own test suite, dbstl has also been tested against, and passes, the following test suites:
MS STL test suite
SGI STL test suite


Womadelaide Adds Another 50 Acts to 2020 Program
Ziggy Marley and Laura Marling lead a corker of a second line-up announcement.
by BroadsheetEight-time Grammy winner Ziggy Marley and British folk darling Laura Marling have joined the 2020 Womadelaide line-up, along with 48 other additional acts.
Marley is famously the son of reggae legend Bob Marley, but he’s had a well-documented career of his own, releasing eight albums with his band The Melody Makers and seven solo records.
Marling, who led the mid-2000s nu-folk wave in the UK (alongside Noah and the Whale and Mumford & Sons) will make her Womad debut with a stripped-back solo set.
Other acts announced today are Brazil’s “king of samba rock” Jorge Ben Jor; Aussie vocalist Kate Miller-Heidke; Yorta Yorta rapper and multi-talent Briggs; Aussie rock trio Dyson Stringer Cloher; dance floor filler Late Night Tuff Guy; and Papua New Guinea-born powerhouse Ngaiire, whose striking live shows fuse fashion, art and music. Rounding out the local contingent are beatmaker Oisima and one of Adelaide’s busiest live acts, Dr Piffle & the Burlap Band.
This second line-up joins the already announced Aldous Harding, Mavis Staples, Bill Callahan, Hiatus Kaiyote and more.
Womadelaide is on from March 6 to 9 at Botanic Park. Full line-up here.


How and WHy Documenting in Python
Welcome to your complete guide to documenting Python code. Whether you’re documenting a small script or a large project, whether you’re a beginner or a seasoned Pythonista, this guide will cover everything you need to know.
Hopefully, if you’re reading this tutorial, you already know the importance of documenting your code. But if not, then let me quote something Guido mentioned to me at a recent PyCon:
When you write code, you write it for two primary audiences: your users and your developers (including yourself). Both audiences are equally important. If you’re like me, you’ve probably opened up old codebases and wondered to yourself, “What in the world was I thinking?” If you’re having a problem reading your own code, imagine what your users or other developers are experiencing when they’re trying to use or contribute to your code.
In general, commenting is describing your code to/for developers. The intended main audience is the maintainers and developers of the Python code. In conjunction with well-written code, comments help to guide the reader to better understand your code and its purpose and design:
Documenting code is describing its use and functionality to your users. While it may be helpful in the development process, the main intended audience is the users. The following section describes how and when to comment your code.
Basics of Commenting Code
Comments are created in Python using the pound sign (#) and should be brief statements no longer than a few sentences. Here’s a simple example:
Comments to your code should be kept brief and focused. Avoid using long comments when possible. Additionally, you should use the following four essential rules as suggested by Jeff Atwood:
def hello_world():
# A simple comment preceding a simple print statement
print("Hello World")
- Keep comments as close to the code being described as possible. Comments that aren’t near their describing code are frustrating to the reader and easily missed when updates are made.
- Don’t use complex formatting (such as tables or ASCII figures). Complex formatting leads to distracting content and can be difficult to maintain over time.
- Don’t include redundant information. Assume the reader of the code has a basic understanding of programming principles and language syntax.
- Design your code to comment itself. The easiest way to understand code is by reading it. When you design your code using clear, easy-to-understand concepts, the reader will be able to quickly conceptualize your intent.
- Remember that comments are designed for the reader, including yourself, to help guide them in understanding the purpose and design of the software.
Type hinting was added to Python 3.5 and is an additional form to help the readers of your code. In fact, it takes Jeff’s fourth suggestion from above to the next level. It allows the developer to design and explain portions of their code without commenting. Here’s a quick example:
def hello_name(name: str) -> str:
return(f"Hello {name}")
From examining the type hinting, you can immediately tell that the function expects the input name to be of a type str, or string. You can also tell that the expected output of the function will be of a type str, or string, as well. While type hinting helps reduce comments, take into consideration that doing so may also make extra work when you are creating or updating your project documentation.
Now that we’ve learned about commenting, let’s take a deep dive into documenting a Python code base. In this section, you’ll learn about docstrings and how to use them for documentation. This section is further divided into the following sub-sections:
- Docstrings Background: A background on how docstrings work internally within Python
- Docstring Types: The various docstring “types” (function, class, class method, module, package, and script)
- Docstring Formats: The different docstring “formats” (Google, NumPy/SciPy, reStructured Text, and Epytext)
How is this output generated? Since everything in Python is an object, you can examine the directory of the object using the dir() command. Let’s do that and see what find:
>>> dir(str)
['__add__', ..., '__doc__', ..., 'zfill'] # Truncated for readability
Any other custom object can be manipulated:
def say_hello(name):
print(f"Hello {name}, is it me you're looking for?")
say_hello.__doc__ = "A simple function that says hello... Richie style"
Python has one more feature that simplifies docstring creation. Instead of directly manipulating the __doc__ property, the strategic placement of the string literal directly below the object will automatically set the __doc__ value. Here’s what happens with the same example as above:
def say_hello(name):
"""A simple function that says hello... Richie style"""
print(f"Hello {name}, is it me you're looking for?")
>>> help(say_hello)


--- layout: post authors: ["Greg Wilson"] title: Evaluation Revisited date: 2013-04-08 time: "10:00:00" tags: ["Assessment"] ---
Caitlyn Pickens (a graduate student at Michigan State who is interning with us this summer) has just posted an article about the validity of different kinds of assessment. Caitlyn's goal is to build some tools we can use to gauge the impact Software Carpentry is having—like almost everything involving human beings, it turns out to be more complicated than it first appears, and her post helps lay out the background knowledge needed to understand why.


Gröbner bases techniques enable computations in quotient polynomial rings (algebras). In particular, if the algebra is finite-dimensional as a vector space such computations boiil down to linear algebra.
* Defining a quotient ring
* Multiplication table
* Solving systems of equations via eigenvalues
Given an ideal I in a polynomial ring R,
k = QQ; R = k[x,y,z]; I = ideal {x^2+y^2+z^2-4, x^2+2*y^2-5, x*y*z-y}
one can define the quotient ring:
R0 = R/I; describe R0
The (ring) dimension of the quotient ring is 0
dim R0
iff the k-vector space dimension is finite. Standard monomials with respect to the monomial order (chosen for R) for a k-basis for R/I.
B = basis R0
The technology behind the basis function is simple: the basis elements are exactly monomials not divisible by the generators of the initial ideal of I,
leadTerm I
For a positive-dimensional quotient ring, e.g., the coordinate ring of the twisted cubic
use R; R1 = R/ideal{y-x^2, z-x^3}
one can not get a finite k-basis
dim R1
basis R1
but it is possible to get a part of the infinite basis given by standard monomials by specifying a degree (range of degrees):
basis(3,R1)
basis(0,5,R1)
Every element of a quotient ring is stored in its normal form, which is a linear combination of standard monomials representing its coset.
use R
f = random(2,R)
g = random(2,R)
RtoR0 = map(R0,R) -- maps are written right-to-left
RtoR0 f
RtoR0 g
Note that two random quadric polynomials get rewritten in terms of standard monomials exclusively. Internally this is accomplished by the polynomial division relative to a Gröbner basis.
print(f*g); RtoR0(f*g)
lift(RtoR0(f*g),R) == (f*g) % I
The standard basis and the multiplication table for a 0-dimensional ring
use R0; describe R0
B = flatten entries basis R0 -- a list of standard monomials
Table table(B,B,(a,b)->a*b)
determine the quotient ring.
Assume I⊂R is a 0-dimensional ideal, for instance, take our running example:
print I
For every polynomial function g∈R we can construct a multiplication matrix Mg representing the operator [f] ↦[gf] ∈R/I relative to the standard basis.
multiplicationMatrix = (g,B) -> (
n := #B;
matrix apply(n, i->apply(n,j->toCC coefficient(B#j,g*B#i)))
)
Then the eigenvalues of Mg are the values of the function g at the points of V(I).
M = multiplicationMatrix(x^2+y+z,B)
eigenvalues M
To solve a system of polynomial equations one could compute all possible values for one of the coordinates
M = multiplicationMatrix(z,B)
eigenvalues M
and proceed using a back-substitution (of computed values for z).


Please wait...
PressPlay
Dashboard
Admin
Account
My Account
Email Integration
User Management
Training
Support
Logout
Account Plan
PP Full
Any
Update Only
Save as new
Users by plans:
Name / Email
Status
Plan
Notes
Actions
First Name Last Name (email)
#
Created at
#
Projects
#
Edit
Log In
Add User


Gradient One
Gradient Two
Gradient Three
Pattern One
Pattern Two
Pattern Three
settings
Settings
message
Messages


| Adams Peak | |
|---|---|
| location | sabragamuva Sri lanka |
| elivation | 2243 m |
| Mountain range | Samanala |
Though not the highest mountain of Sri Lanka, the striking pyramid of Adam's Peak (7,360 ft) is certainly the most remarkable. A depression in the rocky summit resembles a huge footprint, which has been venerated as a sacred sigh from remote antiquity. This was identified by Buddhists as the Buddha's footprint, by Hindus as that of Shiva, and by Muslims as Adam's. Later the Portuguese attributed it to St. Thomas the Apostle. The Mahawamsa tells how the sacred footprint was imprinted by the departing Buddha on his third visit to Lanka, but the site did not become an object of regular Buddhist pilgrimage until the Polonnaruwa period, when Vijayabahu I built resting houses for pilgrims and King Nissankamalla himself, in the year 1201, climbed to the top and worshipped the spot. The Muslim tradition of a footprint of Adam, first of the prophets, goes back to gnostic sources as early as the Mahawamsa itself. According to the legend, Adam was hurled from Paradise for his disobedience and stood in penance for a thousand years on one foot at the top of Adam's Peak, after which he was reunited with Eve on Mt. Arafat overlooking Mecca. By the ninth century, this footprint was consequently considered one of the most sacred sites in the world.


Common secret key y:
Encrypting and Decrypting the Message
Message:
Encrypt
Cipher text:
Decrypt
Decrypted message:


Okay, I guess we have to turn to plan B.
What's plan B?
Why wasn't that plan A?
- The Big Band Theory : "The Lizard-Spock Expansion"
doveryai no proveryai (trust, but verify)
- Russian proverb adopted as signature phrase by Ronald Reagan
Two functions f and g are provided as inputs to checkio. The first function f is the primary function and the second function g is the backup. Use your coding skills to return a third function h which returns the same output as f unless f raises an exception or returns None. In this case h should return the same output as g. If both f and g raise exceptions or return None, then h should return None.
As a second output, h should return a status string indicating whether the function values are the same and if either function erred. A function errs if it raises an exception or returns a null value (None).
The status string should be set to: "same" if f and g return the same output and neither errs, "different" if f and g return different outputs and neither errs, "f_error" if f errs but not g, "g_error" if g errs but not f, or "both_error" if both err.
Input: Two functions: f (primary) and g (backup).
Output: A function h which takes arbitrary inputs and returns a two-tuple.
Example:
f = lambda x,y: x+y g = lambda x,y: (x**2 - y**2)/(x-y) checkio(f,g)(1,3) == (4,"same") checkio(f,g)(1,1.01) == (2.01,"different") # numerical precision difference checkio(f,g)(1,1) == (2,"g_error") # g divides by zero
How it is used: This is an exercise in working with functions as first class objects.
Precondition:
hasattr(f,'__call__');
hasattr(g,'__call__')