{% extends "base.html" %} {% block content %}
War search begins usually in the early afternoon on Friday (Eastern Standard time) and war begins Saturday.
If you don’t want to participate in war, please let a leader know by Thursday at the latest. Leaders will kick you before war search, and invite you back after. In the event the clan is full, please join cult legion until Saturday and try again. All war participants are expected to attack twice. No attacks will result in demotion (if you are elder) or member being kicked.
We have a dibbs site. Please use it. Dibb a base you are pretty sure you can 3 star, and is at your town hall level or higher. Check the dibb website before attack to be sure no one has dibbed the base. Refreshing your screen is advised as it is constantly being updated.
We do have a war alliance with Seven Kingdoms. They are a continually warring clan. They send members over to top us up for our war. We have members that go to their clan when they wish to participate in war more often.


| Package | Description |
|---|---|
| etri.sdn.controller.module.devicemanager | |
| etri.sdn.controller.module.firewall | |
| etri.sdn.controller.protocol.packet |
| Modifier and Type | Method and Description |
|---|---|
private Entity |
OFMDeviceManager.getDestEntityFromPacket(Ethernet eth)
Gets a (partial) entity for the destination from the packet.
|
private Entity |
OFMDeviceManager.getSourceEntityFromPacket(Ethernet eth,
IOFSwitch sw,
int ofPort)
Parses an entity from an
Ethernet packet. |
private int |
OFMDeviceManager.getSrcNwAddr(Ethernet eth,
long dlAddr)
Gets IP address from packet if the packet is either an ARP a DHCP packet.
|
| Modifier and Type | Method and Description |
|---|---|
boolean |
FirewallRule.matchesFlow(long switchDpid,
short inPort,
Ethernet packet,
WildcardsPair wildcards)
Matches this rule to a given flow - incoming packet.
|
| Modifier and Type | Method and Description |
|---|---|
Ethernet |
Ethernet.setDestinationMACAddress(byte[] destinationMACAddress) |
Ethernet |
Ethernet.setDestinationMACAddress(java.lang.String destinationMACAddress) |
Ethernet |
Ethernet.setEtherType(short etherType) |
Ethernet |
Ethernet.setPad(boolean pad)
Pad this packet to 60 bytes minimum, filling with zeros?
|
Ethernet |
Ethernet.setPriorityCode(byte priorityCode) |
Ethernet |
Ethernet.setSourceMACAddress(byte[] sourceMACAddress) |
Ethernet |
Ethernet.setSourceMACAddress(java.lang.String sourceMACAddress) |
Ethernet |
Ethernet.setVlanID(short vlanID) |


HTML5, CSS3, ES6, JavaScript, jQuery, Bootstrap, Bulma, Node.js, AJAX, MySQL, NoSQL, Express, HandlebarsJS, Git, Github, npm, Postman
About inRHYTHM is a biorhythm calculating and reporting program that graphically displays the current status of the users biorhythm and the next month of data points to allow for future planning based on the predicted data.
Features: JavaScript, Node, Express, Handlebars, MySQL, Sequelize, Passport


Train ACE Event
Tagger
Train ACE Event Tagger uses one or more APF files
to
train the pattern and model files used by the Ace event
tagger. It is
invoked by
xjet
AceJet.TrainEventTagger propertyFile fileList
docDir outDir [glarfDir glarfFileExtension]
where
- propertyFile
- Jet properties file
- fileList
- a list of the documents to be processed, one document doc
per line
(for document doc, the text file is assumed to be doc.sgm and the APF file doc.apf.xml)
- docDir
- the path of the directory containing both
the text and APF files for the
documents
- outDir
- the path of the directory which will contain all the generated
pattern, feature, and model files
- glarfDir
- if present, the path of the directory containing the GLARF
triples for the documents
- glarfFileExtension
- (required if glarfDir is present) the file extension of each
GLARF triples file
Files Generated
Human-readable report
eventPatternReport.log:
report of patterns acquired
Pattern file and classifier models used by event tagger
eventPatterns.log:
machine-readable set of event patterns
argModel.log: maxent
model to classify an entity/value mention as an argument / not an
argument
corefModel.log:
maxent model to classify whether two event mentions belong to the same
event
eventModel.log:
maxent model to classify whether a trigger word triggers an event
roleModel.log:
maxent model to assign a role to an argument
Temporary files (including Feature files used to train classifiers)
argFeatureFile.log
argFeatureHalfFile.log
argModelHalf.log
corefFeatureFile.log
eventFeatureFile.log
eventPatternsHalf.log
roleFeatureFile.log
roleFeatureHalfFile.log
roleModelHalf.log


contribute to the community
View Other Members posts
Todays most popular thread
Latest Coin stats
View your account and settings
Leave the Forums


AP Top News at 7:56 a.m. EST
Aide recounts actions tying Trump to delay in Ukraine funds
Democrat Edwards wins reelection in conservative Louisiana
Sanders stars with Biden, Warren absent at California forum
Iran supreme leader warns ‘thugs' amid gas price protests
Hong Kong protesters fight off police with fire and arrows
US, S Korea postpone joint exercise criticized by N Korea
White House urgently ramps up push for drug cost legislation
Sorry, wrong number: Statistical benchmark comes under fire
Last-minute audible: Kaepernick back to school for workout
Hip waders on: Venice braces for another exceptional tide
Copyright 2019 The Associated Press. All rights reserved. This material may not be published, broadcast, rewritten or redistributed.


Main Page
Related Pages
Modules
Data Structures
Files
Directories
Modules
Here is a list of all modules:
Board Drivers
Buttons Driver - LUFA/Drivers/Board/Buttons.h
ATAVRUSBRF01
BENITO
BUMBLEB
EVK527
JMDBU2
MICROSIN162
MINIMUS
OLIMEX162
STK525
STK526
UDIP
USBFOO
USBKEY
USBTINYMKII
Dataflash Driver - LUFA/Drivers/Board/Dataflash.h
EVK527
AT45DB321C
STK525
AT45DB321C
STK526
AT45DB642D
USBKEY
AT45DB642D
XPLAIN
AT45DB642D
Joystick Driver - LUFA/Drivers/Board/Joystick.h
BUMBLEB
EVK527
STK525
STK526
USBKEY
LEDs Driver - LUFA/Drivers/Board/LEDs.h
ADAFRUITU4
ATAVRUSBRF01
BENITO
BLACKCAT
BUI
BUMBLEB
CULV3
EVK527
JMDBU2
MAXIMUS
MICROSIN162
MINIMUS
OLIMEX162
RZUSBSTICK
STK525
STK526
TEENSY
UDIP
UNO
USBFOO
USBKEY
USBTINYMKII
XPLAIN
Temperature Sensor Driver - LUFA/Drivers/Board/Temperature.h
Common Utility Headers - LUFA/Drivers/Common/Common.h
Board Types
Debugging Macros
Endian and Bit Macros
Function/Variable Attributes
Miscellaneous Drivers
ANSI Terminal Escape Codes - LUFA/Drivers/Misc/TerminalCodes.h
On-chip Peripheral Drivers
ADC Driver - LUFA/Drivers/Peripheral/ADC.h
Series U4, U6 and U7 Model ADC Driver
SPI Driver - LUFA/Drivers/Peripheral/SPI.h
Serial Stream Driver - LUFA/Drivers/Peripheral/SerialStream.h
Serial USART Driver - LUFA/Drivers/Peripheral/Serial.h
TWI Driver - LUFA/Drivers/Peripheral/TWI.h
Series U4, U6 and U7 Model TWI Driver
Simple Task Scheduler - LUFA/Scheduler/Scheduler.h
USB Class Drivers
Audio Class Driver
Audio Class Device Mode Driver
Common Class Definitions
CDC-ACM (Virtual Serial) Class Driver
CDC Class Device Mode Driver
CDC Class Host Mode Driver
Common Class Definitions
HID Class Driver
Common Class Definitions
HID Class Device Mode Driver
HID Class Host Mode Driver
MIDI Class Driver
Common Class Definitions
MIDI Class Device Mode Driver
MIDI Class Host Mode Driver
Mass Storage Class Driver
Common Class Definitions
Mass Storage Class Device Mode Driver
Mass Storage Class Host Mode Driver
Printer Class Driver
Common Class Definitions
Printer Class Host Mode Driver
RNDIS (Networking) Class Driver
Common Class Definitions
RNDIS Class Device Mode Driver
RNDIS Class Host Mode Driver
Still Image Class Driver
Common Class Definitions
Still Image Class Host Mode Driver
USB Core - LUFA/Drivers/USB/USB.h
Device Management
Endpoint Management
Endpoint Data Reading and Writing
Read/Write of Multi-Byte Streams
Read/Write of Primitive Data Types
Endpoint Packet Management
Endpoint and Pipe Stream Callbacks
HID Report Parser
Input/Output/Feature Masks
Host Management
Pipe Management
Pipe Control Request Management
Pipe Data Reading and Writing
Read/Write of Multi-Byte Streams
Read/Write of Primitive Data Types
Pipe Packet Management
Standard USB Requests
USB Descriptors
Configuration Descriptor Parser
USB Events
USB Interface Management
USB Mode Tokens
USB On The Go (OTG) Management
Generated by
1.7.2


🕄P-estim.at
It doesn't matter whether you enter values in hours, days or furlongs, as long as you use the same unit everywhere. Unit conversion might be added later.
| # | Work package | Best-case estimate | Most likely estimate | Worst-case estimate | |
|---|---|---|---|---|---|
| 1 | Dig hole | 1 | 3 | 6 | |
| 2 | Fill hole | 2 | 2.5 | 4 | |


User stories:
I can pass a URL as a parameter and I will receive a shortened URL in the JSON response.
When I visit that shortened URL, it will redirect me to my original link.
Example creation usage:
https://shortener.glitch.me/new/https://www.google.com https://shortener.glitch.me/new/http://foo.com:80
Example creation output:
{ "original_url":"http://foo.com:80", "short_url":"https://shortener.glitch.me/8170" }
Usage:
https://shortener.glitch.me/0
Will redirect to:
https://www.google.com/


Montly Music Playlist
June Playlist
- Candy - Baekhyun
[Delight - The 2nd Mini Album]
- Mayday - Crush [homemade 1]
- Knock - ASTRO [GATEWAY]
- Zombie - DAY6
[The Book of Us: The Demon]
- God's Menu - Stray Kids
[GO LIVE]
- Can't You See Me? - TXT
[The Dream Chapter: ETERNITY]


|
My
Dad's Gone Crazy
(Eminem) |
|
Hailie:
Daddy what are you doing? Eminem and Hailie: Okay then!  Eminem: I'm goin' to hell! Who's comin' with me???!? Hailie: Somebody please help him! I think my dad's gone crazy... Verse 1 There's no mountain I can't climb, there's no tower too high, no plane that I can't learn how to fly what do I gotta do to get through to you, to show you there ain't nothin' I can't take this chainsaw to?   When will it stop?  Hailie, tell 'em baby,(My Dad's Lost It!!) Chorus There's really nothin' else to say, I...  Can't you see why I'm so mean? If y'all leave me alone this wouldn't be my M.O. I wouldn't have to go, eenee, meenee, meini, mo, catch a homo by his toe, man I don't know no more am I the only fuckin' one who's normal any more? Dad...  More pain inside of my brain than the eyes of a little girl inside of a plane aimed at the World Trade, standin' on Ronnie's grave, screamin' at the sky, till clouds gather, it's Clyde Mathers and Bonnie Jade and that's pretty much the gist of it, the parents are pissed but the kids love it. 9 millimeter heater stashed in 2 seaters with meat cleavers I don't blame you, I wouldn't let Hailie listen to me neither...


{% extends "_base.html" %} {% block content %}
Track the changes to a selected list of pages related to coronavirus.
| Version | Date recorded | Changes |
|---|---|---|
| Version {{version.sha}} | Date recorded {{version["date-recorded"]}} | Changes{% if version.sha in has_parent_version %}View{% endif %} |
{% if datapackage['created'] %} Created on {{datapackage['created']|format_datestring}}. {% endif %} {% if datapackage['updated'] %} Last updated on {{datapackage['updated']|format_datestring}}. {% endif %} {% if datapackage['update_frequency'] %} Updated {{datapackage['update_frequency']}}. {% endif %}
{% endif %}Available in a machine readable format using the data package specification. {% if datapackage.licenses %} {% if datapackage.licenses|length > 1 %} Available under the following licences:
Downloads:
Compiled from the following sources:
Managed by:
If you’ve got a question about the service history or want to feedback, get in touch.


Test suite results
| result: |
failed |
| totalTime: |
36 |
| numTestTotal: |
1 |
| numTestPasses: |
0 |
| numTestFailures: |
1 |
| numCommandPasses: |
4 |
| numCommandFailures: |
1 |
| numCommandErrors: |
0 |
| Selenium Version: |
2.0 |
| Selenium Revision: |
a1 |
|
|
testCase1.html
| testCase1 |
| open |
/ |
Timed out after 30000ms |
| assertTitle |
exact:Enjoy*Study |
|
| clickAndWait |
link=Selenium Auto Exec Server(AES) |
|
| assertTitle |
Selenium Auto Exec Server(AES) |
|
| clickAndWait |
link=English |
|
| assertTitle |
Selenium Auto Exec Server(AES) |
|
| clickAndWait |
link=Firefox |
|
| verifyTextPresent |
Firefox |
| |
|
info: Starting test /selenium-server/tests/testCase1.html
info: Executing: |open | / | |
info: onXhrStateChange(): xhr.readyState = 1 method = HEAD time =<PHONE_NUMBER>968
info: onXhrStateChange(): xhr.readyState = 1 method = HEAD time =<PHONE_NUMBER>968
info: onXhrStateChange(): xhr.readyState = 2 method = HEAD time =<PHONE_NUMBER>156
info: onXhrStateChange(): xhr.readyState = 3 method = HEAD time =<PHONE_NUMBER>156
info: onXhrStateChange(): xhr.readyState = 4 method = HEAD time =<PHONE_NUMBER>156
warn: currentTest.recordFailure: Timed out after 30000ms
info: Executing: |assertTitle | exact:Enjoy*Study | |
error: modifyWindow: Window was closed!
info: Executing: |clickAndWait | link=Selenium Auto Exec Server(AES) | |
error: modifyWindow: Window was closed!
error: modifyWindow: Window was closed!
error: modifyWindow: Window was closed!
error: modifyWindow: Window was closed!
info: Executing: |assertTitle | Selenium Auto Exec Server(AES) | |
error: modifyWindow: Window was closed!
error: modifyWindow: Window was closed!
info: Executing: |clickAndWait | link=English | |
error: modifyWindow: Window was closed!
error: modifyWindow: Window was closed!
error: modifyWindow: Window was closed!
error: modifyWindow: Window was closed!
error: modifyWindow: Window was closed!
error: modifyWindow: Window was closed!
info: Executing: |assertTitle | Selenium Auto Exec Server(AES) | |
error: modifyWindow: Window was closed!
error: modifyWindow: Window was closed!
info: Executing: |clickAndWait | link=Firefox | |
error: modifyWindow: Window was closed!
error: modifyWindow: Window was closed!
error: modifyWindow: Window was closed!
error: modifyWindow: Window was closed!
error: modifyWindow: Window was closed!
info: Executing: |verifyTextPresent | Firefox | |
error: modifyWindow: Window was closed!
error: modifyWindow: Window was closed!


Pellentesque {{dynamicTooltipText}}, sit amet venenatis urna cursus eget nunc scelerisque viverra mauris, in aliquam. Tincidunt lobortis feugiat vivamus at left eget arcu dictum varius duis at consectetur lorem. Vitae elementum curabitur right nunc sed velit dignissim sodales ut eu sem integer vitae. Turpis egestas bottom pharetra convallis posuere morbi leo urna, fading at elementum eu, facilisis sed odio morbi quis commodo odio. In cursus delayed turpis massa tincidunt dui ut. Custom template nunc sed velit dignissim sodales ut eu sem integer vitae. Turpis egestas
I can even contain HTML. Check me out!
I can have a custom class. Check me out!
A lightweight, extensible directive for fancy tooltip creation. The tooltip directive supports multiple placements, optional transition animation, and more.
There are three versions of the tooltip: tooltip
, tooltip-template
, and
tooltip-html-unsafe
:
tooltip
takes text only and will escape any HTML provided.tooltip-template
takes text that specifies the location of a template to use for the tooltip.tooltip-html-unsafe
takes whatever HTML is provided and displays it in a tooltip; it's called "unsafe" because the HTML is not sanitized. The user is responsible for ensuring the
content is safe to put into the DOM!The tooltip directives provide several optional attributes to control how they will display:
tooltip-placement
: Where to place it? Defaults to "top", but also accepts "bottom", "left", "right".tooltip-animation
: Should it fade in and out? Defaults to "true".tooltip-popup-delay
: For how long should the user have to have the mouse over the element before the tooltip shows (in milliseconds)? Defaults to 0.tooltip-trigger
: What should trigger a show of the tooltip? Note: this attribute is no longer observable. See tooltip-enable
.tooltip-enable
: Is it enabled? It will enable or disable the configured
tooltip-trigger
.tooltip-append-to-body
: Should the tooltip be appended to $body
instead of the parent element?tooltip-class
: Custom class to be applied to the tooltip.The tooltip directives require the $position
service.
Triggers
The following show triggers are supported out of the box, along with their provided hide triggers:
mouseenter
: mouseleave
click
: click
focus
: blur
For any non-supported value, the trigger will be used to both show and hide the tooltip.
$tooltipProvider
Through the $tooltipProvider
, you can change the way tooltips and popovers behave by default; the attributes above always take precedence. The following methods are available:
setTriggers( obj )
: Extends the default trigger mappings mentioned above with mappings of your own. E.g. { 'openTrigger': 'closeTrigger' }
.options( obj )
: Provide a set of defaults for certain tooltip and popover attributes. Currently supports 'placement', 'animation', 'popupDelay', and
appendToBody
. Here are the defaults:
placement: 'top', animation: true, popupDelay: 0, appendToBody: false


Overview
Apache Annotator provides software modules to facilitate annotation tools in web browser environments. For example, it could be used in web-based document viewers or browser extensions that let users highlight phrases and place virtual sticky notes on the pages they visit.
The modules are written in TypeScript, and distributed as Javascript/ECMAScript modules on NPM. Read further for a high-level description of the code functionality, or get started with it directly!
What is in the box
Selector tools
The main functionality Apache Annotator offers is to map a Web Annotation Selector to the segment of a document it corresponds to, sometimes called ‘anchoring’ a Selector; and, vice versa, to create a Selector that describes a given selection in the document precisely and unambiguously, such that other Web Annotation software knows exactly where it points to. The purpose of Selectors is to point at any part of a document without requiring any modification of the document itself.
The W3C Web Annotation Data Model outlines a number of different selectors types, to accomodate various use case on different types of documents and selections (e.g. an annotation may target a phrase of text, or a region within an image). The table below shows the full list of defined types and the implementation status of each.
| Selector | Description | Implemented? |
|---|---|---|
| Fragment | Uses the fragment part of an IRI defined by the representation’s media type. | No |
| CSS | CSS Selectors allow for a wide variety of well supported ways to describe the path to an element in a web page. | Yes (for DOM) |
| XPath | Implements an XPath based selection. | No |
| Text Quote | This Selector describes a range of text, including some of the text immediately before (a prefix) and after (a suffix) it to distinguish between multiple copies of the same sequence of characters. | Yes (for DOM and on any text) |
| Text Position | This Selector describes a range of text by recording the start and end positions of the selection in the stream. | Yes (for DOM and on any text) |
| Data Position | Similar to the Text Position Selector, the Data Position Selector uses the same properties but works at the byte in bitstream level rather than the character in text level. | No |
| SVG | An SvgSelector defines an area through the use of the Scalable Vector Graphics standard. | No |
| Range | A Range Selector can be used to identify the beginning and the end of the selection by using other Selectors. | Yes (for DOM) |
| Refinement | Select a part of a selection, rather than as a selection of the complete resource. | Yes |
Web Annotation JSON validator
The source code also includes a script for validating Web Annotation Data Model JSON documents against the data model schema. Having installed from source, one can run:
$ yarn validate --url https://raw.githubusercontent.com/w3c/web-annotation-tests/master/tools/samples/correct/anno1.json
With the --url
option you can pass in a URL or a local path to a JSON file.
See some example JSON files from the W3C. Note that this validator only tests the data model is followed, and not e.g. whether its target actually exists.
What Apache Annotator is not
Apache Annotator is not an all-in-one annotation tool; rather, it helps others create annotation tools. It does not have opinions regarding in which database on which computer annotations are stored, nor how they are made, exchanged or displayed. Those questions are considered application-specific and left to the developer. Our goal is that the developer can focus on exactly those questions, and forget about issues that are common among annotation tools: finding the part in the document that is being annotated, dealing with changes in the annotated document, ensuring compatibility with other tools, and so on.


Seattle Salmon Cookies Projected Sales
Add New Store
Store Name:
Minimum Customers:
Maximum Customers:
Average Cookies
per Customer:
Add New Store


These classes were added to support the Perspectives Manager project. They include support for a blackboard system, whereby sub-applications can post items to a blackboard and other sub-applications can listen for changes to the blackboard and respond. There is also support for bundles (Madura) Bundles) and dynamic menus, ie the menu changes depending on which sub-application you are focussed on.


Rotate - up arrow, Move Left - left arrow, Move Right - right arrow,
Move Down - down arrow, Fast Drop - space key
Tetris is a game wherein the goal is to completely fill rows of the grid with the falling shapes in order to accrue points. This causes the rows to be removed and all filled squares above that row to drop down one row. Each row is worth 100 base points and removing more rows increases the base points by 100 points per row removed plus a reward of: two to the power of number of rows removed minus one (i.e. three rows will get 300 base points and 400 reward points for a total of 700 points). Finally, the level speeds up the rate at which the shapes fall and increases by one every two minutes that the game is played.


The include widget provides a simple mechanism for composing views from reusable fragments of html. This makes it easy to keep common page elements, such as headers, navigation, and footers, in separate files for maintainability.
The markup inserted by an include widget can also contain additional widget declarations, even other includes. This allows includes to act as a simple templating system for composing views.


David Coulthard believes Mattia Binotto can fix Ferrari's issues
by Louis ShawDavid Coulthard has backed Mattia Binotto to sort out Ferrari's problems before the start of next season. The Italian boss is in his first season as Ferrari leader and has had to learn the challenges of managing a formula 1 team the hard way.
The relationship between their two drivers seems fragile and Binotto is going to have to work hard to fix it.
“I think Mattia [Binotto] has the strength of character and enough history within Ferrari to sit them down and say ‘look guys, this isn’t acceptable’,” Coulthard told Channel 4.
“It’s subtle, but the facts are the facts, you cannot deny the facts otherwise definitely the relationship is all over.
“I think they will shake hands, but you’re dealing with two different people in two different phases of their life, never mind their career.
“Right now Charles doesn’t know what he doesn’t know at 21. He hasn’t got the life experience of Seb, so he’ll just be like ‘okay, I’m not going to put myself in that position again’.
“And in the case of Seb, he knows he’s running out of time. Does he have enough time left in his career to be able to get a World Championship at Ferrari?”
The fact that they have two drivers at different ends of their careers has made things tough. Both want to be the number one and prove that they are faster than the other.
It will be interesting to see how Ferrari manage to the situation and if they have to bring in some tough team orders to ensure they don't crash into each other.


Verticator shows vertical indicators
On vertical slides only
By default, the Verticator bullets are black. Verticator.js assumes that you have a light theme (like this one), and has the colors set in CSS accordingly.
If a dark background (a hex color) is set through an attribute of data-background or data-background-color on a slide (a section), the Verticator bullet will be white.
Keep in mind that not all themes will also change the color of regular text to an opposite color by changing this attribute! The themes 'simple', 'black' and 'white' work allright though. If needed, the code can be found in the beginning of those CSS files.
If your theme is dark, let Verticator know by setting it in the options:
Reveal.initialize({
...
verticator: {
darktheme: true
},
plugins: [ Verticator ]
Now the Verticator colors will be white on all normal slides and black on slides that are set to a light background with attributes.
You can set the main color of the Verticator bullets to a specific color. You can use standard CSS named colors, hex or rgb ones:
Reveal.initialize({
...
verticator: {
color: 'red'
},
plugins: [ Verticator ]
For a light theme, the Verticator colors will be red on all normal slides and (still) white on slides that are set to a dark background with attributes.
You can set the opposite color of the Verticator bullets to a specific color. These apply if a slide has an opposite color to the main background of the theme.
Reveal.initialize({
...
verticator: {
oppositecolor: 'yellow'
},
plugins: [ Verticator ]
For a light theme, the Verticator colors will (still) be black on normal slides and yellow on slides that are set to a dark background with attributes.
Slides that are marked with Reveal.js' 4.0 data-visibility="uncounted"-Property can be skipped (like this slide, disabled by default)
Reveal.initialize({
...
verticator: {
skipuncounted: true
},
plugins: [ Verticator ]
Clicking on a a Verticator bullet jumps to to the corresponding page. This behaviour is enabled by default but can be disabled.
Reveal.initialize({
...
verticator: {
clickable: false
},
plugins: [ Verticator ]
Don’t overdo it: limit vertical slides. You probably don’t want 30 bullets on the right-hand side of your presentation.
Really.


layout one
Here we are using the "css" and "js" helpers to output the stylesheets and scripts that we want for this page. These are custom helpers that can found in the "./test/helpers" directory To show another approach (as well as the advantage of using helpers), we also demonstrate adding styles and scrips with custom variables.
layout one


#{text['display.title']}
Below is a list of attributes that were gathered in FileUpload.java.
Friendly Name:
${friendlyName}
Filename:
${fileName}
File content type:
${contentType}
File size:
${size}
File Location:
The file has been written to:
${location}


\begin{tabbing} text \= more text \= still more text \= last text \\ second row \> \> more \\ .... .... \end{tabbing}
The tabbing environment provides a way to align text in columns. It works by setting tab stops and tabbing to them much the way you do with an ordinary typewriter.
The tabular environment also aligns text in columns, but there are several important differences.
The \hspace command is useful for controlling horizontal space in the tabbing environment.
Note that the commands \=, \', and \` normally produce accents over the subsequent letter. These commands are redefined in the tabbing environment; in this environment it is possible to get the accents by using \a=, \a', and \a`, respectively.
Return to LaTeX Table of Contents


| Param | Description | Optional |
| filter | The filter used to search Product Template and Product Category names. %filter% | true |
| root | The ID of the root node you wish to retrieve. Defaults to null (the root level) | true |
| offset | Specifies the numeric value of the offset you wish to retrieve | true |
| max_num | Specifies the numeric value of the max number of records you wish to receive. Default is 20. | true |
| Param | Description |
| id | The id of the item (Product Category/Template) |
| Data | The name of the item |
| state | Specifies the open or closed state of the element. (used for categories) |
| index | Specifies the index of this element in the current level. |
{ "records":[ { "id":"023d316a-d9d0-11e7-9f54-02425392a518", "type":"category", "data":"Christen Widgets", "state":"closed", "index":0 }, { "id":"01828a4a-d9d0-11e7-8989-02425392a518", "type":"category", "data":"Desktops", "state":"closed", "index":1 } ], "next_offset":2 }


Home
About
Projects
Resume
CYBERPUNK 2077 ART
Below are some of the digital art I created using Cyberpunk 2077's Photo Mode.
Feel free to download them in high resolution by clicking the blue arrow on the right of the image.
Tools
Skills Developed
- Photo Manipulation
- Photography
- Colour Correction
Showcase
01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
2.82 MB
2.50 MB
3.37 MB
3.03 MB
3.00 MB
2.89 MB
3.17 MB
3.24 MB
2.66 MB
3.05 MB
3.20 MB
3.00 MB
2.93 MB
3.23 MB
3.13 MB
BACK TO PROJECTS_


| bartels.test | Ranked Version of von Neumann's Ratio Test for Randomness |
| bias | Prediction Errors ("Biases") of Surface Temperature Forecasts |
| blackhire | Hiring data for eight professions and two races |
| brunner.munzel.test | The Brunner-Munzel Test for Stochastic Equality |
| cd | Coefficient of Dispersion - A Measure of Relative Variability |
| cmh.test | The Cochran-Mantel-Haenszel Chi-square Test |
| data1963 | Population data of ratio of number of senators and representatives to population size in 1963 |
| gini.index | Measures of Relative Variability - Gini Index |
| j.maad | MAAD estimated Robust Standard Deviation |
| laplace.test | Goodness-of-fit tests for the Laplace distribution |
| levene.test | Levene's Test of Equality of Variances |
| lnested.test | Test for a monotonic trend in variances |
| lorenz.curve | Lorenz Curve |
| ltrend.test | Test for a linear trend in variances |
| michigan | Dioxin Levels for Counties in the Upper Peninsula of Michigan |
| mma.test | Mudholkar-McDermott-Aumont test for ordered variances for normal samples |
| neuhauser.hothorn.test | Neuhauser-Hothorn double contrast test for a monotonic trend in variances |
| nig.parameter | Generating parameters for the normal inverse Gaussian (NIG) distribution |
| popdata | Population data in 33 districts of the Tennessee Legislature in 1900, 1960 and 1972 |
| pot | Apertures of chupa-pots from three Philippine communities |
| rjb.test | Test of Normailty - Robust Jarque Bera Test |
| rlm.test | Robust L1 Moment-Based (RLM) Goodness-of-Fit Test for the Laplace Distribution |
| robust.mmm.test | Robust Mudholkar-McDermott-Mudholkar test for ordered variances |
| rqq | Test of Normality using RQQ plots |
| runs.test | Runs Test for Randomness |
| sj.test | Test of Normality - SJ Test |
| symmetry.test | Test of Symmetry |
| zuni | The Zuni data from the law case: Zuni Public School v. United States Department of Education |


Note: the time is an educated guess based on the time and timezone your computer is set to and may not reflect your actual time. CaretTab is guessing your current timezone to be:"{{tz.timezoneFormat(this.tzGuess)}}".


|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
Object org.apache.spark.streaming.dstream.PairDStreamFunctions<K,V>
public class PairDStreamFunctions<K,V>
Extra functions available on DStream of (key, value) pairs through an implicit conversion.
| Constructor Summary | |
|---|---|
PairDStreamFunctions(DStream<scala.Tuple2<K,V>> self,
scala.reflect.ClassTag<K> kt,
scala.reflect.ClassTag<V> vt,
scala.math.Ordering<K> ord)
|
| Method Summary | ||
|---|---|---|
|
cogroup(DStream<scala.Tuple2<K,W>> other,
scala.reflect.ClassTag<W> evidence$10)
Return a new DStream by applying 'cogroup' between RDDs of this DStream and other DStream. |
|
|
cogroup(DStream<scala.Tuple2<K,W>> other,
int numPartitions,
scala.reflect.ClassTag<W> evidence$11)
Return a new DStream by applying 'cogroup' between RDDs of this DStream and other DStream. |
|
|
cogroup(DStream<scala.Tuple2<K,W>> other,
Partitioner partitioner,
scala.reflect.ClassTag<W> evidence$12)
Return a new DStream by applying 'cogroup' between RDDs of this DStream and other DStream. |
|
|
combineByKey(scala.Function1<V,C> createCombiner,
scala.Function2<C,V,C> mergeValue,
scala.Function2<C,C,C> mergeCombiner,
Partitioner partitioner,
boolean mapSideCombine,
scala.reflect.ClassTag<C> evidence$1)
Combine elements of each key in DStream's RDDs using custom functions. |
|
|
flatMapValues(scala.Function1<V,scala.collection.TraversableOnce<U>> flatMapValuesFunc,
scala.reflect.ClassTag<U> evidence$9)
Return a new DStream by applying a flatmap function to the value of each key-value pairs in 'this' DStream without changing the key. |
|
|
fullOuterJoin(DStream<scala.Tuple2<K,W>> other,
scala.reflect.ClassTag<W> evidence$22)
Return a new DStream by applying 'full outer join' between RDDs of this DStream and
other DStream. |
|
|
fullOuterJoin(DStream<scala.Tuple2<K,W>> other,
int numPartitions,
scala.reflect.ClassTag<W> evidence$23)
Return a new DStream by applying 'full outer join' between RDDs of this DStream and
other DStream. |
|
|
fullOuterJoin(DStream<scala.Tuple2<K,W>> other,
Partitioner partitioner,
scala.reflect.ClassTag<W> evidence$24)
Return a new DStream by applying 'full outer join' between RDDs of this DStream and
other DStream. |
|
DStream<scala.Tuple2<K,scala.collection.Iterable<V>>> |
groupByKey()
Return a new DStream by applying groupByKey to each RDD. |
|
DStream<scala.Tuple2<K,scala.collection.Iterable<V>>> |
groupByKey(int numPartitions)
Return a new DStream by applying groupByKey to each RDD. |
|
DStream<scala.Tuple2<K,scala.collection.Iterable<V>>> |
groupByKey(Partitioner partitioner)
Return a new DStream by applying groupByKey on each RDD. |
|
DStream<scala.Tuple2<K,scala.collection.Iterable<V>>> |
groupByKeyAndWindow(Duration windowDuration)
Return a new DStream by applying groupByKey over a sliding window. |
|
DStream<scala.Tuple2<K,scala.collection.Iterable<V>>> |
groupByKeyAndWindow(Duration windowDuration,
Duration slideDuration)
Return a new DStream by applying groupByKey over a sliding window. |
|
DStream<scala.Tuple2<K,scala.collection.Iterable<V>>> |
groupByKeyAndWindow(Duration windowDuration,
Duration slideDuration,
int numPartitions)
Return a new DStream by applying groupByKey over a sliding window on this DStream. |
|
DStream<scala.Tuple2<K,scala.collection.Iterable<V>>> |
groupByKeyAndWindow(Duration windowDuration,
Duration slideDuration,
Partitioner partitioner)
Create a new DStream by applying groupByKey over a sliding window on this DStream. |
|
|
join(DStream<scala.Tuple2<K,W>> other,
scala.reflect.ClassTag<W> evidence$13)
Return a new DStream by applying 'join' between RDDs of this DStream and other DStream. |
|
|
join(DStream<scala.Tuple2<K,W>> other,
int numPartitions,
scala.reflect.ClassTag<W> evidence$14)
Return a new DStream by applying 'join' between RDDs of this DStream and other DStream. |
|
|
join(DStream<scala.Tuple2<K,W>> other,
Partitioner partitioner,
scala.reflect.ClassTag<W> evidence$15)
Return a new DStream by applying 'join' between RDDs of this DStream and other DStream. |
|
|
leftOuterJoin(DStream<scala.Tuple2<K,W>> other,
scala.reflect.ClassTag<W> evidence$16)
Return a new DStream by applying 'left outer join' between RDDs of this DStream and
other DStream. |
|
|
leftOuterJoin(DStream<scala.Tuple2<K,W>> other,
int numPartitions,
scala.reflect.ClassTag<W> evidence$17)
Return a new DStream by applying 'left outer join' between RDDs of this DStream and
other DStream. |
|
|
leftOuterJoin(DStream<scala.Tuple2<K,W>> other,
Partitioner partitioner,
scala.reflect.ClassTag<W> evidence$18)
Return a new DStream by applying 'left outer join' between RDDs of this DStream and
other DStream. |
|
|
mapValues(scala.Function1<V,U> mapValuesFunc,
scala.reflect.ClassTag<U> evidence$8)
Return a new DStream by applying a map function to the value of each key-value pairs in 'this' DStream without changing the key. |
|
DStream<scala.Tuple2<K,V>> |
reduceByKey(scala.Function2<V,V,V> reduceFunc)
Return a new DStream by applying reduceByKey to each RDD. |
|
DStream<scala.Tuple2<K,V>> |
reduceByKey(scala.Function2<V,V,V> reduceFunc,
int numPartitions)
Return a new DStream by applying reduceByKey to each RDD. |
|
DStream<scala.Tuple2<K,V>> |
reduceByKey(scala.Function2<V,V,V> reduceFunc,
Partitioner partitioner)
Return a new DStream by applying reduceByKey to each RDD. |
|
DStream<scala.Tuple2<K,V>> |
reduceByKeyAndWindow(scala.Function2<V,V,V> reduceFunc,
Duration windowDuration)
Return a new DStream by applying reduceByKey over a sliding window on this DStream. |
|
DStream<scala.Tuple2<K,V>> |
reduceByKeyAndWindow(scala.Function2<V,V,V> reduceFunc,
Duration windowDuration,
Duration slideDuration)
Return a new DStream by applying reduceByKey over a sliding window. |
|
DStream<scala.Tuple2<K,V>> |
reduceByKeyAndWindow(scala.Function2<V,V,V> reduceFunc,
Duration windowDuration,
Duration slideDuration,
int numPartitions)
Return a new DStream by applying reduceByKey over a sliding window. |
|
DStream<scala.Tuple2<K,V>> |
reduceByKeyAndWindow(scala.Function2<V,V,V> reduceFunc,
Duration windowDuration,
Duration slideDuration,
Partitioner partitioner)
Return a new DStream by applying reduceByKey over a sliding window. |
|
DStream<scala.Tuple2<K,V>> |
reduceByKeyAndWindow(scala.Function2<V,V,V> reduceFunc,
scala.Function2<V,V,V> invReduceFunc,
Duration windowDuration,
Duration slideDuration,
int numPartitions,
scala.Function1<scala.Tuple2<K,V>,Object> filterFunc)
Return a new DStream by applying incremental reduceByKey over a sliding window. |
|
DStream<scala.Tuple2<K,V>> |
reduceByKeyAndWindow(scala.Function2<V,V,V> reduceFunc,
scala.Function2<V,V,V> invReduceFunc,
Duration windowDuration,
Duration slideDuration,
Partitioner partitioner,
scala.Function1<scala.Tuple2<K,V>,Object> filterFunc)
Return a new DStream by applying incremental reduceByKey over a sliding window. |
|
|
rightOuterJoin(DStream<scala.Tuple2<K,W>> other,
scala.reflect.ClassTag<W> evidence$19)
Return a new DStream by applying 'right outer join' between RDDs of this DStream and
other DStream. |
|
|
rightOuterJoin(DStream<scala.Tuple2<K,W>> other,
int numPartitions,
scala.reflect.ClassTag<W> evidence$20)
Return a new DStream by applying 'right outer join' between RDDs of this DStream and
other DStream. |
|
|
rightOuterJoin(DStream<scala.Tuple2<K,W>> other,
Partitioner partitioner,
scala.reflect.ClassTag<W> evidence$21)
Return a new DStream by applying 'right outer join' between RDDs of this DStream and
other DStream. |
|
void |
saveAsHadoopFiles(String prefix,
String suffix,
Class<?> keyClass,
Class<?> valueClass,
Class<? extends org.apache.hadoop.mapred.OutputFormat<?,?>> outputFormatClass,
org.apache.hadoop.mapred.JobConf conf)
Save each RDD in this DStream as a Hadoop file. |
|
|
saveAsHadoopFiles(String prefix,
String suffix,
scala.reflect.ClassTag<F> fm)
Save each RDD in this DStream as a Hadoop file. |
|
void |
saveAsNewAPIHadoopFiles(String prefix,
String suffix,
Class<?> keyClass,
Class<?> valueClass,
Class<? extends org.apache.hadoop.mapreduce.OutputFormat<?,?>> outputFormatClass,
org.apache.hadoop.conf.Configuration conf)
Save each RDD in this DStream as a Hadoop file. |
|
|
saveAsNewAPIHadoopFiles(String prefix,
String suffix,
scala.reflect.ClassTag<F> fm)
Save each RDD in this DStream as a Hadoop file. |
|
|
updateStateByKey(scala.Function1<scala.collection.Iterator<scala.Tuple3<K,scala.collection.Seq<V>,scala.Option<S>>>,scala.collection.Iterator<scala.Tuple2<K,S>>> updateFunc,
Partitioner partitioner,
boolean rememberPartitioner,
scala.reflect.ClassTag<S> evidence$5)
Return a new "state" DStream where the state for each key is updated by applying the given function on the previous state of the key and the new values of each key. |
|
|
updateStateByKey(scala.Function1<scala.collection.Iterator<scala.Tuple3<K,scala.collection.Seq<V>,scala.Option<S>>>,scala.collection.Iterator<scala.Tuple2<K,S>>> updateFunc,
Partitioner partitioner,
boolean rememberPartitioner,
RDD<scala.Tuple2<K,S>> initialRDD,
scala.reflect.ClassTag<S> evidence$7)
Return a new "state" DStream where the state for each key is updated by applying the given function on the previous state of the key and the new values of each key. |
|
|
updateStateByKey(scala.Function2<scala.collection.Seq<V>,scala.Option<S>,scala.Option<S>> updateFunc,
scala.reflect.ClassTag<S> evidence$2)
Return a new "state" DStream where the state for each key is updated by applying the given function on the previous state of the key and the new values of each key. |
|
|
updateStateByKey(scala.Function2<scala.collection.Seq<V>,scala.Option<S>,scala.Option<S>> updateFunc,
int numPartitions,
scala.reflect.ClassTag<S> evidence$3)
Return a new "state" DStream where the state for each key is updated by applying the given function on the previous state of the key and the new values of each key. |
|
|
updateStateByKey(scala.Function2<scala.collection.Seq<V>,scala.Option<S>,scala.Option<S>> updateFunc,
Partitioner partitioner,
scala.reflect.ClassTag<S> evidence$4)
Return a new "state" DStream where the state for each key is updated by applying the given function on the previous state of the key and the new values of the key. |
|
|
updateStateByKey(scala.Function2<scala.collection.Seq<V>,scala.Option<S>,scala.Option<S>> updateFunc,
Partitioner partitioner,
RDD<scala.Tuple2<K,S>> initialRDD,
scala.reflect.ClassTag<S> evidence$6)
Return a new "state" DStream where the state for each key is updated by applying the given function on the previous state of the key and the new values of the key. |
| Methods inherited from class Object |
|---|
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
|---|
public PairDStreamFunctions(DStream<scala.Tuple2<K,V>> self, scala.reflect.ClassTag<K> kt, scala.reflect.ClassTag<V> vt, scala.math.Ordering<K> ord)
| Method Detail |
|---|
public DStream<scala.Tuple2<K,scala.collection.Iterable<V>>> groupByKey()
groupByKey
to each RDD. Hash partitioning is used to
generate the RDDs with Spark's default number of partitions.
public DStream<scala.Tuple2<K,scala.collection.Iterable<V>>> groupByKey(int numPartitions)
groupByKey
to each RDD. Hash partitioning is used to
generate the RDDs with numPartitions
partitions.
numPartitions
- (undocumented)
public DStream<scala.Tuple2<K,scala.collection.Iterable<V>>> groupByKey(Partitioner partitioner)
groupByKey
on each RDD. The supplied
org.apache.spark.Partitioner is used to control the partitioning of each RDD.
partitioner
- (undocumented)
public DStream<scala.Tuple2<K,V>> reduceByKey(scala.Function2<V,V,V> reduceFunc)
reduceByKey
to each RDD. The values for each key are
merged using the associative reduce function. Hash partitioning is used to generate the RDDs
with Spark's default number of partitions.
reduceFunc
- (undocumented)
public DStream<scala.Tuple2<K,V>> reduceByKey(scala.Function2<V,V,V> reduceFunc, int numPartitions)
reduceByKey
to each RDD. The values for each key are
merged using the supplied reduce function. Hash partitioning is used to generate the RDDs
with numPartitions
partitions.
reduceFunc
- (undocumented)numPartitions
- (undocumented)
public DStream<scala.Tuple2<K,V>> reduceByKey(scala.Function2<V,V,V> reduceFunc, Partitioner partitioner)
reduceByKey
to each RDD. The values for each key are
merged using the supplied reduce function. org.apache.spark.Partitioner is used to control
the partitioning of each RDD.
reduceFunc
- (undocumented)partitioner
- (undocumented)
public <C> DStream<scala.Tuple2<K,C>> combineByKey(scala.Function1<V,C> createCombiner, scala.Function2<C,V,C> mergeValue, scala.Function2<C,C,C> mergeCombiner, Partitioner partitioner, boolean mapSideCombine, scala.reflect.ClassTag<C> evidence$1)
createCombiner
- (undocumented)mergeValue
- (undocumented)mergeCombiner
- (undocumented)partitioner
- (undocumented)mapSideCombine
- (undocumented)evidence$1
- (undocumented)
public DStream<scala.Tuple2<K,scala.collection.Iterable<V>>> groupByKeyAndWindow(Duration windowDuration)
groupByKey
over a sliding window. This is similar to
DStream.groupByKey()
but applies it over a sliding window. The new DStream generates RDDs
with the same interval as this DStream. Hash partitioning is used to generate the RDDs with
Spark's default number of partitions.
windowDuration
- width of the window; must be a multiple of this DStream's
batching interval
public DStream<scala.Tuple2<K,scala.collection.Iterable<V>>> groupByKeyAndWindow(Duration windowDuration, Duration slideDuration)
groupByKey
over a sliding window. Similar to
DStream.groupByKey()
, but applies it over a sliding window. Hash partitioning is used to
generate the RDDs with Spark's default number of partitions.
windowDuration
- width of the window; must be a multiple of this DStream's
batching intervalslideDuration
- sliding interval of the window (i.e., the interval after which
the new DStream will generate RDDs); must be a multiple of this
DStream's batching interval
public DStream<scala.Tuple2<K,scala.collection.Iterable<V>>> groupByKeyAndWindow(Duration windowDuration, Duration slideDuration, int numPartitions)
groupByKey
over a sliding window on this
DStream.
Similar to DStream.groupByKey()
, but applies it over a sliding window.
Hash partitioning is used to generate the RDDs with numPartitions
partitions.
windowDuration
- width of the window; must be a multiple of this DStream's
batching intervalslideDuration
- sliding interval of the window (i.e., the interval after which
the new DStream will generate RDDs); must be a multiple of this
DStream's batching intervalnumPartitions
- number of partitions of each RDD in the new DStream; if not specified
then Spark's default number of partitions will be used
public DStream<scala.Tuple2<K,scala.collection.Iterable<V>>> groupByKeyAndWindow(Duration windowDuration, Duration slideDuration, Partitioner partitioner)
groupByKey
over a sliding window on this
DStream.
Similar to DStream.groupByKey()
, but applies it over a sliding window.
windowDuration
- width of the window; must be a multiple of this DStream's
batching intervalslideDuration
- sliding interval of the window (i.e., the interval after which
the new DStream will generate RDDs); must be a multiple of this
DStream's batching intervalpartitioner
- partitioner for controlling the partitioning of each RDD in the new
DStream.
public DStream<scala.Tuple2<K,V>> reduceByKeyAndWindow(scala.Function2<V,V,V> reduceFunc, Duration windowDuration)
reduceByKey
over a sliding window on this
DStream.
Similar to DStream.reduceByKey()
, but applies it over a sliding window. The new DStream
generates RDDs with the same interval as this DStream. Hash partitioning is used to generate
the RDDs with Spark's default number of partitions.
reduceFunc
- associative reduce functionwindowDuration
- width of the window; must be a multiple of this DStream's
batching interval
public DStream<scala.Tuple2<K,V>> reduceByKeyAndWindow(scala.Function2<V,V,V> reduceFunc, Duration windowDuration, Duration slideDuration)
reduceByKey
over a sliding window. This is similar to
DStream.reduceByKey()
but applies it over a sliding window. Hash partitioning is used to
generate the RDDs with Spark's default number of partitions.
reduceFunc
- associative reduce functionwindowDuration
- width of the window; must be a multiple of this DStream's
batching intervalslideDuration
- sliding interval of the window (i.e., the interval after which
the new DStream will generate RDDs); must be a multiple of this
DStream's batching interval
public DStream<scala.Tuple2<K,V>> reduceByKeyAndWindow(scala.Function2<V,V,V> reduceFunc, Duration windowDuration, Duration slideDuration, int numPartitions)
reduceByKey
over a sliding window. This is similar to
DStream.reduceByKey()
but applies it over a sliding window. Hash partitioning is used to
generate the RDDs with numPartitions
partitions.
reduceFunc
- associative reduce functionwindowDuration
- width of the window; must be a multiple of this DStream's
batching intervalslideDuration
- sliding interval of the window (i.e., the interval after which
the new DStream will generate RDDs); must be a multiple of this
DStream's batching intervalnumPartitions
- number of partitions of each RDD in the new DStream.
public DStream<scala.Tuple2<K,V>> reduceByKeyAndWindow(scala.Function2<V,V,V> reduceFunc, Duration windowDuration, Duration slideDuration, Partitioner partitioner)
reduceByKey
over a sliding window. Similar to
DStream.reduceByKey()
, but applies it over a sliding window.
reduceFunc
- associative reduce functionwindowDuration
- width of the window; must be a multiple of this DStream's
batching intervalslideDuration
- sliding interval of the window (i.e., the interval after which
the new DStream will generate RDDs); must be a multiple of this
DStream's batching intervalpartitioner
- partitioner for controlling the partitioning of each RDD
in the new DStream.
public DStream<scala.Tuple2<K,V>> reduceByKeyAndWindow(scala.Function2<V,V,V> reduceFunc, scala.Function2<V,V,V> invReduceFunc, Duration windowDuration, Duration slideDuration, int numPartitions, scala.Function1<scala.Tuple2<K,V>,Object> filterFunc)
reduceByKey
over a sliding window.
The reduced value of over a new window is calculated using the old window's reduced value :
1. reduce the new values that entered the window (e.g., adding new counts)
2. "inverse reduce" the old values that left the window (e.g., subtracting old counts)
This is more efficient than reduceByKeyAndWindow without "inverse reduce" function. However, it is applicable to only "invertible reduce functions". Hash partitioning is used to generate the RDDs with Spark's default number of partitions.
reduceFunc
- associative reduce functioninvReduceFunc
- inverse reduce functionwindowDuration
- width of the window; must be a multiple of this DStream's
batching intervalslideDuration
- sliding interval of the window (i.e., the interval after which
the new DStream will generate RDDs); must be a multiple of this
DStream's batching intervalfilterFunc
- Optional function to filter expired key-value pairs;
only pairs that satisfy the function are retainednumPartitions
- (undocumented)
public DStream<scala.Tuple2<K,V>> reduceByKeyAndWindow(scala.Function2<V,V,V> reduceFunc, scala.Function2<V,V,V> invReduceFunc, Duration windowDuration, Duration slideDuration, Partitioner partitioner, scala.Function1<scala.Tuple2<K,V>,Object> filterFunc)
reduceByKey
over a sliding window.
The reduced value of over a new window is calculated using the old window's reduced value :
1. reduce the new values that entered the window (e.g., adding new counts)
2. "inverse reduce" the old values that left the window (e.g., subtracting old counts)
This is more efficient than reduceByKeyAndWindow without "inverse reduce" function.
However, it is applicable to only "invertible reduce functions".
reduceFunc
- associative reduce functioninvReduceFunc
- inverse reduce functionwindowDuration
- width of the window; must be a multiple of this DStream's
batching intervalslideDuration
- sliding interval of the window (i.e., the interval after which
the new DStream will generate RDDs); must be a multiple of this
DStream's batching intervalpartitioner
- partitioner for controlling the partitioning of each RDD in the new
DStream.filterFunc
- Optional function to filter expired key-value pairs;
only pairs that satisfy the function are retained
public <S> DStream<scala.Tuple2<K,S>> updateStateByKey(scala.Function2<scala.collection.Seq<V>,scala.Option<S>,scala.Option<S>> updateFunc, scala.reflect.ClassTag<S> evidence$2)
updateFunc
- State update function. If this
function returns None, then
corresponding state key-value pair will be eliminated.evidence$2
- (undocumented)
public <S> DStream<scala.Tuple2<K,S>> updateStateByKey(scala.Function2<scala.collection.Seq<V>,scala.Option<S>,scala.Option<S>> updateFunc, int numPartitions, scala.reflect.ClassTag<S> evidence$3)
numPartitions
partitions.
updateFunc
- State update function. If this
function returns None, then
corresponding state key-value pair will be eliminated.numPartitions
- Number of partitions of each RDD in the new DStream.evidence$3
- (undocumented)
public <S> DStream<scala.Tuple2<K,S>> updateStateByKey(scala.Function2<scala.collection.Seq<V>,scala.Option<S>,scala.Option<S>> updateFunc, Partitioner partitioner, scala.reflect.ClassTag<S> evidence$4)
updateFunc
- State update function. If this
function returns None, then
corresponding state key-value pair will be eliminated.partitioner
- Partitioner for controlling the partitioning of each RDD in the new
DStream.evidence$4
- (undocumented)
public <S> DStream<scala.Tuple2<K,S>> updateStateByKey(scala.Function1<scala.collection.Iterator<scala.Tuple3<K,scala.collection.Seq<V>,scala.Option<S>>>,scala.collection.Iterator<scala.Tuple2<K,S>>> updateFunc, Partitioner partitioner, boolean rememberPartitioner, scala.reflect.ClassTag<S> evidence$5)
updateFunc
- State update function. Note, that this function may generate a different
tuple with a different key than the input key. Therefore keys may be removed
or added in this way. It is up to the developer to decide whether to
remember the partitioner despite the key being changed.partitioner
- Partitioner for controlling the partitioning of each RDD in the new
DStreamrememberPartitioner
- Whether to remember the paritioner object in the generated RDDs.evidence$5
- (undocumented)
public <S> DStream<scala.Tuple2<K,S>> updateStateByKey(scala.Function2<scala.collection.Seq<V>,scala.Option<S>,scala.Option<S>> updateFunc, Partitioner partitioner, RDD<scala.Tuple2<K,S>> initialRDD, scala.reflect.ClassTag<S> evidence$6)
updateFunc
- State update function. If this
function returns None, then
corresponding state key-value pair will be eliminated.partitioner
- Partitioner for controlling the partitioning of each RDD in the new
DStream.initialRDD
- initial state value of each key.evidence$6
- (undocumented)
public <S> DStream<scala.Tuple2<K,S>> updateStateByKey(scala.Function1<scala.collection.Iterator<scala.Tuple3<K,scala.collection.Seq<V>,scala.Option<S>>>,scala.collection.Iterator<scala.Tuple2<K,S>>> updateFunc, Partitioner partitioner, boolean rememberPartitioner, RDD<scala.Tuple2<K,S>> initialRDD, scala.reflect.ClassTag<S> evidence$7)
updateFunc
- State update function. Note, that this function may generate a different
tuple with a different key than the input key. Therefore keys may be removed
or added in this way. It is up to the developer to decide whether to
remember the partitioner despite the key being changed.partitioner
- Partitioner for controlling the partitioning of each RDD in the new
DStreamrememberPartitioner
- Whether to remember the paritioner object in the generated RDDs.initialRDD
- initial state value of each key.evidence$7
- (undocumented)
public <U> DStream<scala.Tuple2<K,U>> mapValues(scala.Function1<V,U> mapValuesFunc, scala.reflect.ClassTag<U> evidence$8)
mapValuesFunc
- (undocumented)evidence$8
- (undocumented)
public <U> DStream<scala.Tuple2<K,U>> flatMapValues(scala.Function1<V,scala.collection.TraversableOnce<U>> flatMapValuesFunc, scala.reflect.ClassTag<U> evidence$9)
flatMapValuesFunc
- (undocumented)evidence$9
- (undocumented)
public <W> DStream<scala.Tuple2<K,scala.Tuple2<scala.collection.Iterable<V>,scala.collection.Iterable<W>>>> cogroup(DStream<scala.Tuple2<K,W>> other, scala.reflect.ClassTag<W> evidence$10)
this
DStream and other
DStream.
Hash partitioning is used to generate the RDDs with Spark's default number
of partitions.
other
- (undocumented)evidence$10
- (undocumented)
public <W> DStream<scala.Tuple2<K,scala.Tuple2<scala.collection.Iterable<V>,scala.collection.Iterable<W>>>> cogroup(DStream<scala.Tuple2<K,W>> other, int numPartitions, scala.reflect.ClassTag<W> evidence$11)
this
DStream and other
DStream.
Hash partitioning is used to generate the RDDs with numPartitions
partitions.
other
- (undocumented)numPartitions
- (undocumented)evidence$11
- (undocumented)
public <W> DStream<scala.Tuple2<K,scala.Tuple2<scala.collection.Iterable<V>,scala.collection.Iterable<W>>>> cogroup(DStream<scala.Tuple2<K,W>> other, Partitioner partitioner, scala.reflect.ClassTag<W> evidence$12)
this
DStream and other
DStream.
The supplied org.apache.spark.Partitioner is used to partition the generated RDDs.
other
- (undocumented)partitioner
- (undocumented)evidence$12
- (undocumented)
public <W> DStream<scala.Tuple2<K,scala.Tuple2<V,W>>> join(DStream<scala.Tuple2<K,W>> other, scala.reflect.ClassTag<W> evidence$13)
this
DStream and other
DStream.
Hash partitioning is used to generate the RDDs with Spark's default number of partitions.
other
- (undocumented)evidence$13
- (undocumented)
public <W> DStream<scala.Tuple2<K,scala.Tuple2<V,W>>> join(DStream<scala.Tuple2<K,W>> other, int numPartitions, scala.reflect.ClassTag<W> evidence$14)
this
DStream and other
DStream.
Hash partitioning is used to generate the RDDs with numPartitions
partitions.
other
- (undocumented)numPartitions
- (undocumented)evidence$14
- (undocumented)
public <W> DStream<scala.Tuple2<K,scala.Tuple2<V,W>>> join(DStream<scala.Tuple2<K,W>> other, Partitioner partitioner, scala.reflect.ClassTag<W> evidence$15)
this
DStream and other
DStream.
The supplied org.apache.spark.Partitioner is used to control the partitioning of each RDD.
other
- (undocumented)partitioner
- (undocumented)evidence$15
- (undocumented)
public <W> DStream<scala.Tuple2<K,scala.Tuple2<V,scala.Option<W>>>> leftOuterJoin(DStream<scala.Tuple2<K,W>> other, scala.reflect.ClassTag<W> evidence$16)
this
DStream and
other
DStream. Hash partitioning is used to generate the RDDs with Spark's default
number of partitions.
other
- (undocumented)evidence$16
- (undocumented)
public <W> DStream<scala.Tuple2<K,scala.Tuple2<V,scala.Option<W>>>> leftOuterJoin(DStream<scala.Tuple2<K,W>> other, int numPartitions, scala.reflect.ClassTag<W> evidence$17)
this
DStream and
other
DStream. Hash partitioning is used to generate the RDDs with numPartitions
partitions.
other
- (undocumented)numPartitions
- (undocumented)evidence$17
- (undocumented)
public <W> DStream<scala.Tuple2<K,scala.Tuple2<V,scala.Option<W>>>> leftOuterJoin(DStream<scala.Tuple2<K,W>> other, Partitioner partitioner, scala.reflect.ClassTag<W> evidence$18)
this
DStream and
other
DStream. The supplied org.apache.spark.Partitioner is used to control
the partitioning of each RDD.
other
- (undocumented)partitioner
- (undocumented)evidence$18
- (undocumented)
public <W> DStream<scala.Tuple2<K,scala.Tuple2<scala.Option<V>,W>>> rightOuterJoin(DStream<scala.Tuple2<K,W>> other, scala.reflect.ClassTag<W> evidence$19)
this
DStream and
other
DStream. Hash partitioning is used to generate the RDDs with Spark's default
number of partitions.
other
- (undocumented)evidence$19
- (undocumented)
public <W> DStream<scala.Tuple2<K,scala.Tuple2<scala.Option<V>,W>>> rightOuterJoin(DStream<scala.Tuple2<K,W>> other, int numPartitions, scala.reflect.ClassTag<W> evidence$20)
this
DStream and
other
DStream. Hash partitioning is used to generate the RDDs with numPartitions
partitions.
other
- (undocumented)numPartitions
- (undocumented)evidence$20
- (undocumented)
public <W> DStream<scala.Tuple2<K,scala.Tuple2<scala.Option<V>,W>>> rightOuterJoin(DStream<scala.Tuple2<K,W>> other, Partitioner partitioner, scala.reflect.ClassTag<W> evidence$21)
this
DStream and
other
DStream. The supplied org.apache.spark.Partitioner is used to control
the partitioning of each RDD.
other
- (undocumented)partitioner
- (undocumented)evidence$21
- (undocumented)
public <W> DStream<scala.Tuple2<K,scala.Tuple2<scala.Option<V>,scala.Option<W>>>> fullOuterJoin(DStream<scala.Tuple2<K,W>> other, scala.reflect.ClassTag<W> evidence$22)
this
DStream and
other
DStream. Hash partitioning is used to generate the RDDs with Spark's default
number of partitions.
other
- (undocumented)evidence$22
- (undocumented)
public <W> DStream<scala.Tuple2<K,scala.Tuple2<scala.Option<V>,scala.Option<W>>>> fullOuterJoin(DStream<scala.Tuple2<K,W>> other, int numPartitions, scala.reflect.ClassTag<W> evidence$23)
this
DStream and
other
DStream. Hash partitioning is used to generate the RDDs with numPartitions
partitions.
other
- (undocumented)numPartitions
- (undocumented)evidence$23
- (undocumented)
public <W> DStream<scala.Tuple2<K,scala.Tuple2<scala.Option<V>,scala.Option<W>>>> fullOuterJoin(DStream<scala.Tuple2<K,W>> other, Partitioner partitioner, scala.reflect.ClassTag<W> evidence$24)
this
DStream and
other
DStream. The supplied org.apache.spark.Partitioner is used to control
the partitioning of each RDD.
other
- (undocumented)partitioner
- (undocumented)evidence$24
- (undocumented)
public <F extends org.apache.hadoop.mapred.OutputFormat<K,V>> void saveAsHadoopFiles(String prefix, String suffix, scala.reflect.ClassTag<F> fm)
this
DStream as a Hadoop file. The file name at each batch interval
is generated based on prefix
and suffix
: "prefix-TIME_IN_MS.suffix"
prefix
- (undocumented)suffix
- (undocumented)fm
- (undocumented)public void saveAsHadoopFiles(String prefix, String suffix, Class<?> keyClass, Class<?> valueClass, Class<? extends org.apache.hadoop.mapred.OutputFormat<?,?>> outputFormatClass, org.apache.hadoop.mapred.JobConf conf)
this
DStream as a Hadoop file. The file name at each batch interval
is generated based on prefix
and suffix
: "prefix-TIME_IN_MS.suffix"
prefix
- (undocumented)suffix
- (undocumented)keyClass
- (undocumented)valueClass
- (undocumented)outputFormatClass
- (undocumented)conf
- (undocumented)public <F extends org.apache.hadoop.mapreduce.OutputFormat<K,V>> void saveAsNewAPIHadoopFiles(String prefix, String suffix, scala.reflect.ClassTag<F> fm)
this
DStream as a Hadoop file. The file name at each batch interval is
generated based on prefix
and suffix
: "prefix-TIME_IN_MS.suffix".
prefix
- (undocumented)suffix
- (undocumented)fm
- (undocumented)public void saveAsNewAPIHadoopFiles(String prefix, String suffix, Class<?> keyClass, Class<?> valueClass, Class<? extends org.apache.hadoop.mapreduce.OutputFormat<?,?>> outputFormatClass, org.apache.hadoop.conf.Configuration conf)
this
DStream as a Hadoop file. The file name at each batch interval is
generated based on prefix
and suffix
: "prefix-TIME_IN_MS.suffix".
prefix
- (undocumented)suffix
- (undocumented)keyClass
- (undocumented)valueClass
- (undocumented)outputFormatClass
- (undocumented)conf
- (undocumented)
|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


The routes declaration contains currently only the template ID to use. But when displaying a new page, a bit more is needed sometimes. Let’s improve our routing implementation with two additional features:
'Dashboard is shown'
in the developer console every time the dashboard page is displayed.| Criteria | Exemplary | Adequate | Needs Improvement |
|---|---|---|---|
The two features are implemented and working. Title and code addition also work for a new route added in the routes declaration. |
The two features work, but the behavior is hardcoded and not configurable via the routes declaration. Adding a third route with title and code addition does not work or works partially. |
One of the features is missing or not working properly. |


Copy-paste the stylesheet <link>
into your <head>
before all other stylesheets to load the CSS Aid library.
https://raw.githubusercontent.com/saurav12/css-aid/master/css/cssaid.min.css
For SASS/SCSS - Get it from the repo's scss/custom/_cssaid.scss
Use margin utilities to quickly style the margins of an element. Great for any element.
Use margin utilities to quickly style the margins of an element. Great for any element.
Use *-imp
in the end/suffix to overwrite the styles with !important
Use padding utilities to quickly style the paddings of an element. Great for any element.
Use padding utilities to quickly style the paddings of an element. Great for any element.
Use *-imp
in the end/suffix to overwrite the styles with !important
Make a layout in flex, just by using simple classes. Manage layout, alignment, columns, etc. with ease.
fx
→
display: flex
infx
→
display: inline-flex
fx--fd-r
→
flex-direction: row
fx--fd-rr
→
flex-direction: row-reverse
fx--fd-c
→
flex-direction: column
fx--fd-cr
→
flex-direction: column-reverse
fx--fw-w
→
flex-wrap: wrap
fx--fw-wr
→
flex-wrap: wrap-reverse
fx--fw-nw
→
flex-wrap: no-wrap
fx--ai-fs
→
align-items: flex-start
fx--ai-fe
→
align-items: flex-end
fx--ai-c
→
align-items: center
fx--ai-b
→
align-items: baseline
fx--ai-s
→
align-items: stretch
fx--jc-fs
→
justify-content: flex-start
fx--jc-fe
→
justify-content: flex-end
fx--jc-sa
→
justify-content: space-around
fx--jc-sb
→
justify-content: space-between
Use *-imp
in the end/suffix to overwrite the styles with !important
Use display table utilities to quickly style the layout of an element. Great for any table like layout.
sec--table
→
display: table
sec--table-row
→
display: table-row
sec--table-cell
→
display: table-cell
For full width tables use class .fw
with .sec--table
Use *-imp
in the end/suffix to overwrite the styles with !important
Use vertical alignment utilities to quickly align the layout vertically. Great for any layouts.
valign--t
→
vertical-align: top
valign--m
→
vertical-align: middle
valign--b
→
vertical-align: bottom
Other classes also includes:
valign--bl
→
vertical-align: baseline
valign--tt
→
vertical-align: text-top
valign--tb
→
vertical-align: text-bottom
valign--sub
→
vertical-align: sub
valign--sup
→
vertical-align: sup
Use *-imp
in the end/suffix to overwrite the styles with !important
Use width & height utilities to quickly set width & height to an element.
width--full
→
width: 100%
width--full-vw
→
width: 100vw
width--half
→
width: 50%
width--half-vw
→
width: 50vw
height--full
→
height: 100%
width--full-vh
→
height: 100vh
height--half
→
height: 50%
width--half-vh
→
height: 50vh
You can also use .width--auto
and .height--auto
for resetting width & height respectively.
Use *-imp
in the end/suffix to overwrite the styles with !important
Just use simple classes to change your cursors.
cursor--[cursor-name]
→
cursor: [cursor-name]
Hover your cursor on below columns to see them in action
Use *-imp
in the end/suffix to overwrite the styles with !important
Just use simple classes for social media colors.
color--social-[social-media-name]
→
color: [social-media-name]
Use *-imp
in the end/suffix to overwrite the styles with !important


<lcTechnical>
The <lcTechnical> describes the technical requirements to the learning content and how those requirements are supported by the instructional design.
Category: Learning and training: common content elements


Before Change
break
nb_epoch += 1
min_duration = None
duration = os.path.basename(train_dir)
if "-" in duration:
min_duration, duration = duration.split("-")
min_duration = float(min_duration)
duration = float(duration)
config_dir = os.path.dirname(os.path.dirname(os.path.dirname(train_dir)))
config_yml = config_dir + "/config.yml"
with open(config_yml, "r") as fp:
After Change
nb_epoch += 1
// -- DURATIONS --
duration, min_duration, step = path_to_duration(os.path.basename(train_dir))
config_dir = os.path.dirname(os.path.dirname(os.path.dirname(train_dir)))
config_yml = config_dir + "/config.yml"
with open(config_yml, "r") as fp:


Leveling & Other Areas
__________________
Starting Towns Areas
Other Towns Areas
__________________
Back


This package contains discovery nodes to detect a ROS master in a multi robot system. There are currently two nodes 'master_discovery' and 'zeroconf' which uses different discovery strategies. 'zeroconf' node uses an avahi implementation of zeroconf technique. The 'master_discovery' node sends periodically a multicast message to notify about an available ROS master. Furthermore the ROS master will be monitored for changes. On changes other discovery nodes are notified using a timestamp. This feature is used e.g. by master_sync to syncronize the ROS masters. Moreover an XML-RPC server created by a discovery node helps to avoid a lot of requests on remote ROS master for a synchronization.
For parameterization see ros wiki


If you're new to Mesos
See the getting started page for more information about downloading, building, and deploying Mesos.
If you'd like to get involved or you're looking for support
See our community page for more details.
Multiple Disks
Mesos provides a mechanism for operators to expose multiple disk resources. When
creating persistent volumes frameworks can decide
whether to use specific disks by examining the source
field on the disk
resources offered.
Types of Disk Resources
Disk
resources come in three forms:
- A
Root
disk is presented by not having thesource
set inDiskInfo
. - A
Path
disk is presented by having thePATH
enum set forsource
inDiskInfo
. It also has aroot
which the operator uses to specify the directory to be used to store data. - A
Mount
disk is presented by having theMOUNT
enum set forsource
inDiskInfo
. It also has aroot
which the operator uses to specify the mount point used to store data.
Operators can use the JSON-formated --resources
option on the agent to provide
these different kind of disk resources on agent start-up. Example resource
values in JSON format can be found below. By default (if --resources
is not
specified), the Mesos agent will only make the root disk available to the
cluster.
NOTE: Once you specify any Disk
resource manually (i.e., via the
--resources
flag), Mesos will stop auto-detecting the Root
disk resource.
Hence if you want to use the Root
disk you will need to manually specify it
using the format described below.
Root
disk
A Root
disk is the basic disk resource in Mesos. It usually maps to the
storage on the main operating system drive that the operator has presented to
the agent. Data is mapped into the work_dir
of the agent.
An example resources value for a root disk is shown below. Note that the
operator could optionally specify a role
for the disk, which would result in
statically reserving the disk for a single role.
{
"resources" : [
{
"name" : "disk",
"type" : "SCALAR",
"scalar" : { "value" : 2048 }
}
]
}
Path
disks
A Path
disk is an auxiliary disk resource provided by the operator. This
can be carved up into smaller chunks by creating persistent volumes that use
less than the total available space on the disk. Common uses for this kind of
disk are extra logging space, file archives or caches, or other non
performance-critical applications. Operators can present extra disks on their
agents as Path
disks simply by creating a directory and making that the root
of the Path
in DiskInfo
’s source
.
Path
disks are also useful for mocking up a multiple disk environment by
creating some directories on the operating system drive. This should only be
done in a testing or staging environment. Note that creating multiple Path
disks on the same filesystem requires statically partitioning the available disk
space. For example, suppose a 10GB storage device is mounted to /foo
and the
Mesos agent is configured with two Path
disks at /foo/disk1
and
/foo/disk2
. To avoid the risk of running out of space on the device, disk1
and disk2
should be configured (when the Mesos agent is started) to use at
most 10GB of disk space in total.
An example resources value for a Path
disk is shown below. Note that the
operator could optionally specify a role
for the disk, which would result in
statically reserving the disk for a single role.
{
"resources" : [
{
"name" : "disk",
"type" : "SCALAR",
"scalar" : { "value" : 2048 },
"disk" : {
"source" : {
"type" : "PATH",
"path" : { "root" : "/mnt/data" }
}
}
}
]
}
Mount
disks
A Mount
disk is an auxiliary disk resource provided by the operator. This
cannot be carved up into smaller chunks by frameworks. This lack of
flexibility allows operators to provide assurances to frameworks that they will
have exclusive access to the disk device. Common uses for this kind of disk
include database storage, write-ahead logs, or other performance-critical
applications.
On Linux, Mount
disks must map to a mount
point in the /proc/mounts
table. Operators should mount a physical disk with their preferred file system
and provide the mount point as the root
of the Mount
in DiskInfo
’s
source
.
Aside from the performance advantages of Mount
disks, applications running on
them should be able to rely on disk errors when they attempt to exceed the
capacity of the volume. This holds true as long as the file system in use
correctly propagates these errors. Due to this expectation, the disk/du
isolation is disabled for Mount
disks.
An example resources value for a Mount
disk is shown below. Note that the
operator could optionally specify a role
for the disk, which would result in
statically reserving the disk for a single role.
{
"resources" : [
{
"name" : "disk",
"type" : "SCALAR",
"scalar" : { "value" : 2048 },
"disk" : {
"source" : {
"type" : "MOUNT",
"mount" : { "root" : "/mnt/data" }
}
}
}
]
}
Block
disks
Mesos currently does not allow operators to expose raw block devices. It may do so in the future, but there are security and flexibility concerns that need to be addressed in a design document first.
Implementation
A Path
disk will have sub-directories created within the root
which will be
used to differentiate the different volumes that are created on it. When a
persistent volume on a Path
disk is destroyed, Mesos will remove all the files
and directories stored in the volume, as well as the sub-directory within root
that was created by Mesos for the volume.
A Mount
disk will not have sub-directories created, allowing applications
to use the full file system mounted on the device. This construct allows Mesos
tasks to access volumes that contain pre-existing directory structures. This can
be useful to simplify ingesting data such as a pre-existing Postgres database or
HDFS data directory. Note that when a persistent volume on a Mount
disk is
destroyed, Mesos will remove all the files and directories stored in the volume,
but will not remove the root directory (i.e., the mount point).
Operators should be aware of these distinctions when inspecting or cleaning up remnant data.


ISS recommends shareholders vote against Baker-led offer for HBC
TORONTO — An influential proxy advisory service is recommending shareholders vote against a takeover offer for Hudson's Bay Co. by a group led by the retailer's executive chairman.
by Canadian PressTORONTO — An influential proxy advisory service is recommending shareholders vote against a takeover offer for Hudson's Bay Co. by a group led by the retailer's executive chairman.
Institutional Shareholder Services raised concerns about the disclosures surrounding the $10.30 per share offer by a group led by HBC executive chairman Richard Baker.
A rival offer of $11 per share made by Catalyst Capital Group has been rejected by HBC's special committee because it says the Baker-led group, which holds a 57 per cent stake in the retailer, is not interested in selling its shares.
ISS raised questions about the thoroughness of the sale process and if the agreed transaction maximizes value for minority HBC shareholders.
However, the special committee at HBC says the ISS report is flawed and urged shareholders to support the offer by the Baker-led group. It pointed to an acknowledgment by ISS that there is meaningful downside risk if shareholders don't approve the deal.
Catalyst has asked a regulator to block the privatization bid or, at least, require HBC to amend its information circular. The Ontario Securities Commission is scheduled to hear that matter on Wednesday.
This report by The Canadian Press was first published Dec. 9, 2019.
Companies in this story: (TSX:HBC)
The Canadian Press


- IMMEDIATE - Static variable in interface com.cloudpos.TimeConstants
-
zero timeout
- increaseValue(int, int, int) - Method in interface com.cloudpos.card.MifareCard
-
Increases E-Wallet data value.
- injectPublicKeyCertificate(String, String, byte[], int) - Method in interface com.cloudpos.hsm.HSMDevice
-
Injects the certificate of the public key of the existing key pair.
- injectRootCertificate(int, String, byte[], int) - Method in interface com.cloudpos.hsm.HSMDevice
-
Injects the root certificates to hardware safe module.
- isDeviceExist(String) - Method in class com.cloudpos.POSTerminal
-
If the specified device exists or not.
- isInternal(int) - Method in interface com.cloudpos.pinpad.PINPadDeviceSpec
-
Whether the device is internal.
- isRemovable() - Method in interface com.cloudpos.rfcardreader.RFCardReaderDeviceSpec
-
Whether to support the operation of card remove.
- isTampered() - Method in interface com.cloudpos.hsm.HSMDevice
-
Checks the hardware safe module is tampered or not.


Developer Student Clubs MAIT is a community group for students interested in Google developer technologies and other latest technologies.


This method allows a client to retrieve a report given a Report ID.
Expects the following URL query parameters:
The headers must include a valid authorization token.
If an iReport with the given ID is found, expect:
Status: 200 OK
{
"_id": "1629801524773",
"user_id": "195531486638637056",
"reason": "Spam and trolling",
"guild": "538992072301084683",
"reporter": "297567836254240768",
"created_at": "2021-08-24T10:38:44.773Z",
"audited": false
}
If a report is not found, expect:
Status: 404 Not Found
{
"error": "Report not found."
}
For errors responses, see the response status codes documentation.


| ^a${value} Second(s) Recharge | 30 |
| ${value}% Chance of Activating | 5 |
| ${value} Second Duration | 15 |
| ${value} Damage Absorption | 18 21 24 27 30 33 36 39 42 45 48 51 |
| ${value} Physical Retaliation | min: [3.0, 7.0, 11.0, 17.0, 23.0, 30.0, 37.0, 45.0, 53.0, 64.0, 75.0, 88.0] |
| ${value}% Damage Absorption | 9 10.5 12 13.5 15 16.5 18 19.5 21 22.5 24 25.5 |
| MaxLevel | 8 |
| UltimateLevel | 12 |


#include <b2WorldCallbacks.h>
Public Member Functions | |
| virtual | ~b2ContactListener () |
| virtual void | BeginContact (b2Contact *contact) |
| Called when two fixtures begin to touch. | |
| virtual void | EndContact (b2Contact *contact) |
| Called when two fixtures cease to touch. | |
| virtual void | PreSolve (b2Contact *contact, const b2Manifold *oldManifold) |
| virtual void | PostSolve (b2Contact *contact, const b2ContactImpulse *impulse) |
Implement this class to get contact information. You can use these results for things like sounds and game logic. You can also get contact results by traversing the contact lists after the time step. However, you might miss some contacts because continuous physics leads to sub-stepping. Additionally you may receive multiple callbacks for the same contact in a single time step. You should strive to make your callbacks efficient because there may be many callbacks per time step.
| virtual b2ContactListener::~b2ContactListener | ( | ) | [inline, virtual] |
| virtual void b2ContactListener::BeginContact | ( | b2Contact * | contact | ) | [inline, virtual] |
Called when two fixtures begin to touch.
| virtual void b2ContactListener::EndContact | ( | b2Contact * | contact | ) | [inline, virtual] |
Called when two fixtures cease to touch.
| virtual void b2ContactListener::PostSolve | ( | b2Contact * | contact, | |
| const b2ContactImpulse * | impulse | |||
| ) | [inline, virtual] |
This lets you inspect a contact after the solver is finished. This is useful for inspecting impulses. Note: the contact manifold does not include time of impact impulses, which can be arbitrarily large if the sub-step is small. Hence the impulse is provided explicitly in a separate data structure. Note: this is only called for contacts that are touching, solid, and awake.
| virtual void b2ContactListener::PreSolve | ( | b2Contact * | contact, | |
| const b2Manifold * | oldManifold | |||
| ) | [inline, virtual] |
This is called after a contact is updated. This allows you to inspect a contact before it goes to the solver. If you are careful, you can modify the contact manifold (e.g. disable contact). A copy of the old manifold is provided so that you can detect changes. Note: this is called only for awake bodies. Note: this is called even when the number of contact points is zero. Note: this is not called for sensors. Note: if you set the number of contact points to zero, you will not get an EndContact callback. However, you may get a BeginContact callback the next step.


--- layout: page title: About header-img: "img/about-bg.png" ---
Born from South Korea, worked in US, studied in Norway, South Korea, and now doing master in Munich Germany.


An infusion of immune cells from people who have recovered from COVID-19 could shield those with compromised immune systems from the infection responsible for the disease, a lab-based study of cellular cultures suggests.
People who have recently received a bone marrow or organ transplant or are undergoing cancer treatment have reduced immunity. This makes them especially vulnerable to infections with viruses such as SARS-CoV-2, which causes COVID-19.
The Cellular Therapy Program at Children’s National, a hospital in Washington, D.C., uses a technique called “adoptive immunotherapy” to protect those with weakened immune systems from viruses including cytomegalovirus and the Epstein-Barr virus.
The technique involves isolating T cells that target the virus from the blood of someone recovering from the infection. After the cells have been cultured in a lab, healthcare providers inject them into people with weakened immunity, protecting them from the infection.
A team from Children’s National has now investigated the potential of adoptive immunotherapy to protect against COVID-19.
This preclinical research involved testing the immune capabilities of T cells from individuals recovering from the illness.
“We found that many people who recover from COVID-19 have T cells that recognize and target viral proteins of SARS-CoV-2, giving them immunity from the virus because those T cells are primed to fight it,” says Dr. Michael Keller, a pediatric immunology specialist who led the study.
“This suggests that adoptive immunotherapy using convalescent T cells to target these regions of the virus may be an effective way to protect vulnerable people, especially those with compromised immune systems due to cancer therapy or transplantation.”
These individuals’ vulnerability to infection can prevent or delay the treatments they need.
“This approach could serve as a viable option to protect or treat them, especially since their underlying conditions may make vaccines for SARS-CoV-2 unsafe or ineffective,” says Dr. Catherine Bollard, director of the hospital’s Center for Cancer and Immunology Research.
Dr. Bollard is also the senior author of the new study, which has been published in the journal Blood.
Immune targets
For the research, 46 individuals recovering from COVID-19 donated blood. Most had experienced only mild symptoms, and the researchers analyzed the samples around 36 days after the onset of the symptoms.
They identified T cells that recognized parts of proteins in the virus’s membrane, spike, and nucleocapsid, the shell surrounding its genetic material.
The researchers expanded these immune cells in the lab and found that they responded to the viral proteins by producing interferon gamma, a signaling molecule that orchestrates the immune system’s assault on viruses.
Many of the cells targeted a part of the membrane that is highly conserved, meaning that it changes little, if at all, as the virus evolves. This suggests that the virus may not be able to evolve ways to evade this part of the human immune system.
Vaccines currently in development target key parts of the spike proteins that give coronaviruses their characteristic crown-like appearance.
The authors propose that the highly conserved part of the membrane that they have identified might be another worthwhile target. A vaccine that trained T cells to recognize this part of the virus could provide long-lasting protection against the infection.
The study adds to evidence that even if the number of circulating antibodies declines steeply in the months after SARS-CoV-2 infection, as a recently published preprint of one study suggests, T cells may continue to protect against reinfection.
The authors also note that T cell immunity to two closely related coronaviruses — which cause severe acute respiratory syndrome, or SARS, and Middle East respiratory syndrome, or MERS — appears to persist for years.
Immune System / VaccinesCOVID-19
Written by James Kingsland on November 3, 2020 — Fact checked by Rita Ponce, Ph.D.
back to Homepage


({{amSure}})
Valid only if checked
({{amReallySure}})
Support for $destroy
events.
| Disabled (ng-disabled) | Disabled (disabled) | Valid | Invalid |
|---|---|---|---|
|
|
|
|
|
| Attribute | Required? | Description |
|---|---|---|
ng-disabled
|
optional |
In addition to default functionality, this will add/remove the rx-disabled class on the control wrapper for purposes of styling sibling elements.
|


attach_money
Designed to help you save on groceries by showing you
recipes you can make with the ingredients you have on hand. Just tell us
what is in your pantry, cooler, and freezer!
delete
Cut down on food waste. Over one-third
of food in the US is tossed out or goes uneatten- a staggering 133 billion pounds of food every year!
local_dining
Personal meal plans that make the most of your time and budget!
Avoid the stress of figuring out what's for dinner tonight by saving recipes to
your calendar.


Football: Tampines Rovers win 2019 Singapore Cup in thrilling final
SINGAPORE: Tampines Rovers won the 2019 Komoco Motors Singapore Cup after four different players scored goals to beat Warriors 4-3 on Saturday (Nov 2).
It was a thrilling back-and-forth at Jalan Besar Stadium with Warriors taking the lead with a goal from Khairul Nizam, but Tampines soon equalised thanks to Irwan Shah.
Warriors struck back mere minutes later as Khairul Nizam scored his second goal for the night, however a long-range finish from Joel Chew in the 31st minute put Tampines back in contention.
Things were looking grim for Warriors as Amirul Adli and Zehruddin Mehmedovic increased Tampines’ lead.
A late goal from Fairoz Hasan gave Warriors some much-needed hope, but Tampines ultimately proved too strong to handle.
Tampines lifted the Singapore Cup for the first time in more than a decade, last emerging victorious in 2002, 2004, and 2006.
“We knew before the game that Warriors had really capable players up front who could cause us problems, but it is our ability to stay calm and composed that made the difference, so kudos to the boys,” said Tampines first-team coach Gavin Lee.
“This win is all about the club; it is a team effort and that will always be the case in football. Overall, I am really heartened by the team’s performance as their progress over the season has been really satisfying to see.”
Meanwhile in the third placing match, Geylang International faced Brunei DPMM in an intense game that ended 2-2 at full-time. But a dramatic penalty shootout saw Geylang trump DPMM with a final score of 12-11, earning Geylang the third spot.
For winning the Singapore Cup, Tampines took home the prize money of S$70,000, while Warriors got S$45,000. Geylang and DPMM received S$25,000 and S$10,000 respectively.
DPMM’s Varankou finished as the tournament’s joint-top scorer alongside Warriors pair Sahil Suhaimi and Khairul Nizam, having each scored four goals.
Saturday’s match marks the end of the domestic football season, which saw DPMM win the AIA Singapore Premier League (SPL) in September. The 2020 SPL season will begin in February.
Tampines' win also means that Hougang United will earn a spot in the 2020 Asian Football Confederation (AFC) Cup, as Tampines already sealed their berth after finishing second in the SPL.


<<< BACK <<<
STM-117: VeriSol
Authors
Wang, Yuepeng and Lahiri, Shuvendu K and Chen, Shuo and Pan, Rong and Dillig, Isil and Born, Cody and Naseer, Immad and Ferles, Kostas
Venue and Year
VSTTE, 2019
Original Work
Formal Verification of Workflow Policies for Smart Contracts in Azure Blockchain
Defense Modality
Additive
Core Method(s)
formal
Input-Output Mapping
source code => report
Targeted Contracts
EVM-compatible
Threat Model
Vulnerable contract, malicious contract, or both
vulnerable contract
Targeted Vulnerabilities


Contained buttons
Default
Primary
Secondary
Disabled
Link
Text buttons
Default
Primary
Secondary
Disabled
Link
Outline buttons
Default
Primary
Secondary
Disabled
Link


WebConversation wc = new WebConversation(); WebRequest req = new GetMethodWebRequest( "http://www.meterware.com/testpage.html" ); WebResponse resp = wc.getResponse( req );The response may now be manipulated either as pure text (via the
getText()
method), as a DOM (via the getDOM()
method),
or by using the various other methods described below. Because the above sequence is so common, it can be abbreviated to:
WebConversation wc = new WebConversation(); WebResponse resp = wc.getResponse( "http://www.meterware.com/testpage.html" );
WebResponse
class, above. That page could therefore be obtained as follows:
WebConversation wc = new WebConversation(); WebResponse resp = wc.getResponse( "http://www.httpunit.org/doc/cookbook.html" ); // read this page WebLink link = resp.getLinkWith( "response" ); // find the link link.click(); // follow it WebResponse jdoc = wc.getCurrentPage(); // retrieve the referenced pageImage links can be found as well. The
WebResponse.getLinkWithImageText()
method can look up links by examining
the ALT text, or the HttpUnitOptions.setImagesTreatedAsAltText
method can cause ALT text to be treated as
ordinary searchable text.
getTables()
method will return an array of the top-level
tables in the page (that is, those which are not nested within other tables), in the order in which they appear in the
document. Given a table, you can ask for one of its cells, and treat the result either as text or a DOM or ask for
and tables, links, or forms nested within it. For example, the following code will confirm that the first table in the page
has 4 rows and 3 columns, and that there is a single link in the last cell of the first row:
WebTable table = resp.getTables()[0]; assertEquals( "rows", 4, table.getRowCount() ); assertEquals( "columns", 3, table.getColumnCount() ); assertEquals( "links", 1, table.getTableCell( 0, 2 ).getLinks().length );In most cases, the purpose of a test is to verify the text, rather than the formatting. HttpUnit provides shortcuts to do this. For example, imagine that the second table in the page should look like this:
| Name | Color |
|---|---|
| gules | red |
| sable | black |
The following JUnit code will verify it:
String[][] colors = resp.getTables()[1].asText(); assertEquals( "Name", colors[0][0] ); assertEquals( "Color", colors[0][1] ); assertEquals( "gules", colors[1][0] ); assertEquals( "red", colors[1][1] ); assertEquals( "sable", colors[2][0] ); assertEquals( "black", colors[2][1] );Note that the
asText()
method, used to convert an entire table into an array of String ignores all formatting tags.
At times, entire rows or columns of a table may be used for appearance purposes only. You can ignore rows or columns consisting
only of images or empty tags by invoking purgeEmptyCells
on the table.
In many cases, tables begin with some fixed text and the purpose of the test is to verify the dynamic portion. As a general rule,
the first cell will contain something fixed and you can search for it - even if the table is nested inside other tables. Thus,
the above table could have been found with:
String[][] colors = resp.getTableStartingWith( "Name" );which has the advantage of being immune to many page formatting changes which might make it the third or fourth table.
A dynamic web site tends to have many html forms, each of which contains various kinds of controls: text boxes, pull-down menus, radio buttons, and so on. The HTML for these controls vary widely; however, the intent is roughly the same, so HttpUnit makes them look the same.
There are a few basic things that a tester is likely to want to do with a form. The most obvious first step is to verify the controls and their default values; if they are correct, the tester will generally make some changes and submit the form to see how the system responds. HttpUnit makes both tasks easy.
The examples below assume the following form definition:
WebForm form = resp.getForms()[0]; // select the first form in the page assertEquals( "La Cerentolla", form.getParameterValue( "Name" ) ); assertEquals( "Chinese", form.getParameterValue( "Food" ) ); assertEquals( "Manayunk", form.getParameterValue( "Location" ) ); assertEquals( "on", form.getParameterValue( "CreditCard" ) );Note that all controls are treated alike, with the exception of the checkbox.
Simulating the submission of the form can be done most simply by obtaining the form object and calling its 'submit' method, possibly modifying the form parameters beforehand. For example, to correct the restaurant type and indicate that it does not accept credit cards:
form.setParameter( "Food", "Italian" ); // select one of the permitted values for food form.removeParameter( "CreditCard" ); // clear the check box form.submit(); // submit the formAnd of course the test could then proceed to examine the response to this submission as well, obtaining it from
wc.getCurrentPage()
.
Without frames, web interaction tends to be straightforward and sequential. There is one current active page at a time, and each new page replaces the old one that referenced it. Frames change that, allowing multiple active pages simultaneously, and allowing for the possibility that a link from one active page could result in the replacement of a different page.
HttpUnit supports frames by providing methods on the WebConversation class to examine those frames which are currently active. Each response replaces the contents of the appropriate frame, which is not necessarily the topmost frame ("_top"). In the following scenation, there are two active subframes, named "overview" and "details":
WebConversation wc = new WebConversation(); WebResponse top = wc.getResponse( "http://www.meterware.com/Frames.html" ); // read a page with two frames WebResponse summary = wc.getFrameContents( "summary" ); // read the summary frame WebLink link = summary.getLinkWith( "Cake Recipe" ); // find the link (which targets "details" ); link.click(); // click on it WebResponse response= wc.getFrameContents( "details" ); // retrieve the details frame


Next: Examples of APPEND and NCONC clauses, Previous: Value Accumulation Clauses, Up: Value Accumulation Clauses
;; Collect all the symbols in a list. (loop for i in '(bird 3 4 turtle (1 . 4) horse cat) when (symbolp i) collect i) ⇒ (BIRD TURTLE HORSE CAT) ;; Collect and return odd numbers. (loop for i from 1 to 10 if (oddp i) collect i) ⇒ (1 3 5 7 9) ;; Collect items into local variable, but don't return them. (loop for i in '(a b c d) by #'cddr collect i into my-list finally (print my-list)) |> (A C) ⇒ NIL


Connect to SLAVIC in the Course Register.
SLAVIC
SLAV-165 RUSS & EAST EURO FILM 1 CU CROSS CULTURAL ANALYSIS ALL READINGS AND LECTURES IN ENGLISH 401 LEC MW 2-3:30PM WILL 5 TODOROV V CROSS LISTED: CINE-165 RUSS-165 MAX W/CROSS LIST: 20 SLAV-501 ELEMENTARY POLISH I 1 CU 680 LEC MW 6:30-8PM MCNB 409 DZIEDZIC A MAX: 15 SLAV-506 POLISH/HERITAGE SPEAK II 1 CU SEE SPECIAL MESSAGE IN DEPARTMENT HEADER 680 LEC MW 5-6:30PM MCNB 409 DZIEDZIC A PRIOR LANGUAGE EXPERIENCE REQUIRED MAX: 15 SLAV-517 MEDIEVAL RUSS CULT IDENT 1 CU 401 LEC MW 3:30-5PM WILL 23 VERKHOLANTSEV J CROSS LISTED: COML-235 HIST-219 RUSS-234 MAX W/CROSS LIST: 25 SLAV-590 ELEMENTARY UKRAINIAN 1 CU 680 LEC MW 5-7PM PSYL B50 RUDNYTZKY L MAX: 15 SLAV-619 EAST/WEST MEDIEV EUROPE 1 CU 401 SEM M 12-3PM WILL 737 VERKHOLANTSEV J UNDERGRADUATES NEED PERMISSION CROSS LISTED: COML-619 MAX W/CROSS LIST: 15 SLAV-683 MODERNISMS ACRS BORDERS 1 CU 401 SEM W 2-5PM VANP 627 PLATT/POGGI CROSS LISTED: ARTH-783 COML-683 SECTION MAX: 1 MAX W/CROSS LIST: 30
Return to Course & Room Roster
Comments to:
Office of the University Registrar
University of Pennsylvania
Room 221 Franklin Building
3451 Walnut Street
Philadelphia, PA 19104-6291
Phone:<PHONE_NUMBER> Fax:<PHONE_NUMBER>
<EMAIL_ADDRESS>Updated: Sat Jan 17 08:30:02 2015


| First name: |
|
| Last name: |
|
| Street address: |
|
| Zip |
|
|
| City: |
|
| State: |
|
| Telephone Number: |
|
| Email: |
|
| URL: |
|
| Date of survey: |
|
| High School Graduation Date: |
|
| What did you like most about the campus: |
Students
Location
Campus
Atmosphere
Dorm rooms
sports
|
| What gave rise to your interst in this university: |
Friends
Television
Internet
other
|
|
Recommending GMU to others:
|
|
| Additional Comments: |
|
| Data: |
|
| The average of the numbers: |
|
| The minimum of the numbers: |
|
| The maximum of the numbers: |
|
|
|


Project 2
Security Applications of Natural Language Processing
Craig Kilgo (INFO 644)
Problem
Detect "phishing" attempts by looking at URLs.
Corpus
PhishTank
Moz.com
Corpus - Known Bad
PhishTank
- List of known phishing attempts
- https://cposerst.000webhostapp.com/secure_help.htm
- 23,364 records
Corpus - Known Good
Moz.com Top 500
- Good list of credible URLs (compare to Alexa)
- Just domains
- facebook.com
Corpus - Known Good
Created Bash Script to crawl each of the top 500 domains and extract all links
Generated 35,303 results
Corpus - Known Bad
Created some "synthetic" bad URLs
Used the good URLs:
- Replaced some "o" with "0"
- Replaced some "a" with "α"
Training and Testing
- Used random selection to split the entire dataset into a training and testing set
- Testing set was roughly 33% of the entire sample
Created Model
FastTree Binary Classification
Multiple Additive Regression Trees with Dropouts
- Multiple decision trees are assembled, with some "dropped"
- Fast
- Designed to provide good results while avoiding overfitting
Model Results
| Metric |
Value |
| Accuracy |
0.970 |
| Recall |
0.948 |
| Precision |
0.974 |
| AUC |
0.996 |
| F-measure |
0.961 |