Method that generates a RDD for the given time
Method that generates a RDD for the given time
Method called to start receiving data.
Method called to start receiving data. Subclasses must implement this method.
Method called to stop receiving data.
Method called to stop receiving data. Subclasses must implement this method.
Persist RDDs of this DStream with the default storage level (MEMORY_ONLY_SER)
Persist RDDs of this DStream with the default storage level (MEMORY_ONLY_SER)
Enable periodic checkpointing of RDDs of this DStream
Enable periodic checkpointing of RDDs of this DStream
Time interval after which generated RDD will be checkpointed
Clear metadata that are older than rememberDuration
of this DStream.
Clear metadata that are older than rememberDuration
of this DStream.
This is an internal method that should not be called directly. This default
implementation clears the old generated RDDs. Subclasses of DStream may override
this to clear their own metadata along with the generated RDDs.
Return the StreamingContext associated with this DStream
Return the StreamingContext associated with this DStream
Return a new DStream in which each RDD has a single element generated by counting each RDD of this DStream.
Return a new DStream in which each RDD has a single element generated by counting each RDD of this DStream.
Return a new DStream in which each RDD contains the counts of each distinct value in each RDD of this DStream.
Return a new DStream in which each RDD contains the counts of each distinct value in
each RDD of this DStream. Hash partitioning is used to generate
the RDDs with numPartitions
partitions (Spark's default number of partitions if
numPartitions
not specified).
Return a new DStream in which each RDD contains the count of distinct elements in RDDs in a sliding window over this DStream.
Return a new DStream in which each RDD contains the count of distinct elements in
RDDs in a sliding window over this DStream. Hash partitioning is used to generate
the RDDs with numPartitions
partitions (Spark's default number of partitions if
numPartitions
not specified).
width of the window; must be a multiple of this DStream's batching interval
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
number of partitions of each RDD in the new DStream.
Return a new DStream in which each RDD has a single element generated by counting the number of elements in a sliding window over this DStream.
Return a new DStream in which each RDD has a single element generated by counting the number of elements in a sliding window over this DStream. Hash partitioning is used to generate the RDDs with Spark's default number of partitions.
width of the window; must be a multiple of this DStream's batching interval
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
List of parent DStreams on which this DStream depends on
List of parent DStreams on which this DStream depends on
Return a new DStream containing only the elements that satisfy a predicate.
Return a new DStream containing only the elements that satisfy a predicate.
Return a new DStream by applying a function to all elements of this DStream, and then flattening the results
Return a new DStream by applying a function to all elements of this DStream, and then flattening the results
Apply a function to each RDD in this DStream.
Apply a function to each RDD in this DStream. This is an output operator, so 'this' DStream will be registered as an output stream and therefore materialized.
Apply a function to each RDD in this DStream.
Apply a function to each RDD in this DStream. This is an output operator, so 'this' DStream will be registered as an output stream and therefore materialized.
Generate a SparkStreaming job for the given time.
Generate a SparkStreaming job for the given time. This is an internal method that should not be called directly. This default implementation creates a job that materializes the corresponding RDD. Subclasses of DStream may override this to generate their own jobs.
Retrieve a precomputed RDD of this DStream, or computes the RDD.
Return a new DStream in which each RDD is generated by applying glom() to each RDD of this DStream.
Return a new DStream in which each RDD is generated by applying glom() to each RDD of this DStream. Applying glom() to an RDD coalesces all elements within each partition into an array.
Initialize the DStream by setting the "zero" time, based on which the validity of future times is calculated.
Checks whether the 'time' is valid wrt slideDuration for generating RDD.
Checks whether the 'time' is valid wrt slideDuration for generating RDD. Additionally it also ensures valid times are in strictly increasing order. This ensures that InputDStream.compute() is called strictly on increasing times.
Return a new DStream by applying a function to all elements of this DStream.
Return a new DStream by applying a function to all elements of this DStream.
Return a new DStream in which each RDD is generated by applying mapPartitions() to each RDDs of this DStream.
Return a new DStream in which each RDD is generated by applying mapPartitions() to each RDDs of this DStream. Applying mapPartitions() to an RDD applies a function to each partition of the RDD.
Persist RDDs of this DStream with the default storage level (MEMORY_ONLY_SER)
Persist RDDs of this DStream with the default storage level (MEMORY_ONLY_SER)
Persist the RDDs of this DStream with the given storage level
Persist the RDDs of this DStream with the given storage level
Print the first ten elements of each RDD generated in this DStream.
Print the first ten elements of each RDD generated in this DStream. This is an output operator, so this DStream will be registered as an output stream and there materialized.
Return a new DStream in which each RDD has a single element generated by reducing each RDD of this DStream.
Return a new DStream in which each RDD has a single element generated by reducing each RDD of this DStream.
Return a new DStream in which each RDD has a single element generated by reducing all elements in a sliding window over this DStream.
Return a new DStream in which each RDD has a single element generated by reducing all elements in a sliding window over this DStream. However, the reduction is done incrementally using the old window's reduced value :
associative reduce function
inverse reduce function
width of the window; must be a multiple of this DStream's batching interval
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
Return a new DStream in which each RDD has a single element generated by reducing all elements in a sliding window over this DStream.
Return a new DStream in which each RDD has a single element generated by reducing all elements in a sliding window over this DStream.
associative reduce function
width of the window; must be a multiple of this DStream's batching interval
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
Return a new DStream with an increased or decreased level of parallelism.
Return a new DStream with an increased or decreased level of parallelism. Each RDD in the returned DStream has exactly numPartitions partitions.
Restore the RDDs in generatedRDDs from the checkpointData.
Restore the RDDs in generatedRDDs from the checkpointData. This is an internal method that should not be called directly. This is a default implementation that recreates RDDs from the checkpoint file names stored in checkpointData. Subclasses of DStream that override the updateCheckpointData() method would also need to override this method.
Save each RDD in this DStream as a Sequence file of serialized objects.
Save each RDD in this DStream as a Sequence file of serialized objects.
The file name at each batch interval is generated based on prefix
and
suffix
: "prefix-TIME_IN_MS.suffix".
Save each RDD in this DStream as at text file, using string representation of elements.
Save each RDD in this DStream as at text file, using string representation
of elements. The file name at each batch interval is generated based on
prefix
and suffix
: "prefix-TIME_IN_MS.suffix".
Return all the RDDs between 'fromTime' to 'toTime' (both included)
Return all the RDDs between 'fromTime' to 'toTime' (both included)
Return all the RDDs defined by the Interval object (both end times included)
Time interval after which the DStream generates a RDD
Time interval after which the DStream generates a RDD
Return a new DStream in which each RDD is generated by applying a function on each RDD of 'this' DStream.
Return a new DStream in which each RDD is generated by applying a function on each RDD of 'this' DStream.
Return a new DStream in which each RDD is generated by applying a function on each RDD of 'this' DStream.
Return a new DStream in which each RDD is generated by applying a function on each RDD of 'this' DStream.
Return a new DStream in which each RDD is generated by applying a function on each RDD of 'this' DStream and 'other' DStream.
Return a new DStream in which each RDD is generated by applying a function on each RDD of 'this' DStream and 'other' DStream.
Return a new DStream in which each RDD is generated by applying a function on each RDD of 'this' DStream and 'other' DStream.
Return a new DStream in which each RDD is generated by applying a function on each RDD of 'this' DStream and 'other' DStream.
Return a new DStream by unifying data of another DStream with this DStream.
Return a new DStream by unifying data of another DStream with this DStream.
Another DStream having the same slideDuration as this DStream.
Refresh the list of checkpointed RDDs that will be saved along with checkpoint of this stream.
Refresh the list of checkpointed RDDs that will be saved along with checkpoint of this stream. This is an internal method that should not be called directly. This is a default implementation that saves only the file names of the checkpointed RDDs to checkpointData. Subclasses of DStream (especially those of InputDStream) may override this method to save custom checkpoint data.
Return a new DStream in which each RDD contains all the elements in seen in a sliding window of time over this DStream.
Return a new DStream in which each RDD contains all the elements in seen in a sliding window of time over this DStream.
width of the window; must be a multiple of this DStream's batching interval
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
Return a new DStream in which each RDD contains all the elements in seen in a sliding window of time over this DStream.
Return a new DStream in which each RDD contains all the elements in seen in a sliding window of time over this DStream. The new DStream generates RDDs with the same interval as this DStream.
width of the window; must be a multiple of this DStream's interval.
This is the abstract base class for all input streams. This class provides to methods start() and stop() which called by the scheduler to start and stop receiving data/ Input streams that can generated RDDs from new data just by running a service on the driver node (that is, without running a receiver onworker nodes) can be implemented by directly subclassing this InputDStream. For example, FileInputDStream, a subclass of InputDStream, monitors a HDFS directory for new files and generates RDDs on the new files. For implementing input streams that requires running a receiver on the worker nodes, use NetworkInputDStream as the parent class.


Share your thoughts, knowledge and ideas with the largest community of game developers in the world. If we like what we see, we'll promote your pose on our home page.


about me
I am currently a research staff member in IBM - Haifa research lab in the group of Machine Learning for Healthcare and Life
This site is still under heavy construction
I am currently a research staff member in IBM - Haifa research lab in the group of Machine Learning for Healthcare and Life
This site is still under heavy construction


--- layout: doc title: Documentation ---
This file documents configuration mechanisms for version 4.4 of Proof General, a generic Emacs interface for proof assistants.
Proof General 4.4 has been tested with GNU Emacs 24.4. It is supplied ready customized for the proof assistants Coq, Lego, Isabelle, and HOL.
This manual contains information for customizing to new proof assistants; see the user manual for details about how to use Proof General.
This document was generated by Erik Martin-Dorel on September 18, 2016 using texi2html 1.82.


RDoc::Markup parses plain text documents and attempts to decompose them into their constituent parts. Some of these parts are high-level: paragraphs, chunks of verbatim text, list entries and the like. Other parts happen at the character level: a piece of bold text, a word in code font. This markup is similar in spirit to that used on WikiWiki webs, where folks create web pages using a simple set of formatting rules.
RDoc::Markup and other markup formats do no output formatting, this is handled by the RDoc::Markup::Formatter subclasses.
Besides the RDoc::Markup format, the following formats are built in to RDoc:
markdown |
The markdown format as described by daringfireball.net/projects/markdown/. See RDoc::Markdown for details on the parser and supported extensions. |
rd |
The rdtool format. See RDoc::RD for details on the parser and format. |
tomdoc |
The TomDoc format as described by tomdoc.org/. See RDoc::TomDoc for details on the parser and supported extensions. |
You can choose a markup format using the following methods:
per project |
If you build your documentation with rake use RDoc::Task#markup. If you build your documentation by hand run: rdoc --markup your_favorite_format --write-options and commit .rdoc_options and ship it with your packaged gem. |
per file |
At the top of the file use the :markup: directive to set the default format for the rest of the file. |
per comment |
Use the :markup: directive at the top of a comment you want to write in a different format. |
RDoc::Markup is extensible at runtime: you can add new markup elements to be recognized in the documents that RDoc::Markup parses.
RDoc::Markup is intended to be the basis for a family of tools which share the common requirement that simple, plain-text should be rendered in a variety of different output formats and media. It is envisaged that RDoc::Markup could be the basis for formatting RDoc style comment blocks, Wiki entries, and online FAQs.
This code converts input_string to HTML. The conversion takes place in the convert method, so you can use the same RDoc::Markup converter to convert multiple input strings.
require 'rdoc' h = RDoc::Markup::ToHtml.new(RDoc::Options.new) puts h.convert(input_string)
You can extend the RDoc::Markup parser to recognize new markup sequences, and to add special processing for text that matches a regular expression. Here we make WikiWords significant to the parser, and also make the sequences {word} and <no>text…</no> signify strike-through text. We then subclass the HTML output class to deal with these:
require 'rdoc' class WikiHtml < RDoc::Markup::ToHtml def handle_special_WIKIWORD(special) "" + special.text + "" end end markup = RDoc::Markup.new markup.add_word_pair("{", "}", :STRIKE) markup.add_html("no", :STRIKE) markup.add_special(/\b([A-Z][a-z]+[A-Z]\w+)/, :WIKIWORD) wh = WikiHtml.new markup wh.add_tag(:STRIKE, "", "") puts "#{wh.convert ARGF.read}"
Where Encoding support is available, RDoc will automatically convert all documents to the same output encoding. The output encoding can be set via RDoc::Options#encoding and defaults to Encoding.default_external.
The markup engine looks for a document’s natural left margin. This is used as the initial margin for the document.
Consecutive lines starting at this margin are considered to be a paragraph. Empty lines separate paragraphs.
Any line that starts to the right of the current margin is treated as verbatim text. This is useful for code listings:
3.times { puts "Ruby" }
In verbatim text, two or more blank lines are collapsed into one, and trailing blank lines are removed:
This is the first line This is the second non-blank line, after 2 blank lines in the source markup.
There were two trailing blank lines right above this paragraph, that have been removed. In addition, the verbatim text has been shifted left, so the amount of indentation of verbatim text is unimportant.
For HTML output RDoc makes a small effort to determine if a verbatim section contains ruby source code. If so, the verbatim block will be marked up as HTML. Triggers include “def”, “class”, “module”, “require”, the “hash rocket”# (=>) or a block call with a parameter.
A line starting with an equal sign (=) is treated as a heading. Level one headings have one equals sign, level two headings have two, and so on until level six, which is the maximum (seven hyphens or more result in a level six heading).
For example, the above header was obtained with:
=== Headers
In HTML output headers have an id matching their name. The above example’s HTML is:

Headers

If a heading is inside a method body the id will be prefixed with the method’s id. If the above header where in the documentation for a method such as:
## # This method does fun things # # = Example # # Example of fun things goes here ... def do_fun_things end
The header’s id would be:

Example

The label can be linked-to using SomeClass@Headers. See Links for further details.
A line starting with three or more hyphens (at the current indent) generates a horizontal rule. The more hyphens, the thicker the rule (within reason, and if supported by the output device).
In the case of HTML output, three dashes generate a 1-pixel high rule, four dashes result in 2 pixels, and so on. The actual height is limited to 10 pixels:
--- ----- -----------------------------------------------------
produces:
If a paragraph starts with a “*”, “-”, “<digit>.” or “<letter>.”, then it is taken to be the start of a list. The margin is increased to be the first non-space following the list start flag. Subsequent lines should be indented to this new margin until the list ends. For example:
* this is a list with three paragraphs in the first item. This is the first paragraph. And this is the second paragraph. 1. This is an indented, numbered list. 2. This is the second item in that list This is the third conventional paragraph in the first list item. * This is the second item in the original list
produces:
this is a list with three paragraphs in the first item. This is the first paragraph.
And this is the second paragraph.
This is an indented, numbered list.
This is the second item in that list
This is the third conventional paragraph in the first list item.
This is the second item in the original list
You can also construct labeled lists, sometimes called description or definition lists. Do this by putting the label in square brackets and indenting the list body:
[cat] a small furry mammal that seems to sleep a lot [ant] a little insect that is known to enjoy picnics
produces:
a small furry mammal that seems to sleep a lot
a little insect that is known to enjoy picnics
If you want the list bodies to line up to the left of the labels, use two colons:
cat:: a small furry mammal that seems to sleep a lot ant:: a little insect that is known to enjoy picnics
produces:
cat |
a small furry mammal that seems to sleep a lot |
ant |
a little insect that is known to enjoy picnics |
Notice that blank lines right after the label are ignored in labeled lists:
[one] definition 1 [two] definition 2
produces the same output as
[one] definition 1 [two] definition 2
If you want to introduce a verbatim section right after a list, it has to be less indented than the list item bodies, but more indented than the list label, letter, digit or bullet. For instance:
* point 1 * point 2, first paragraph point 2, second paragraph verbatim text inside point 2 point 2, third paragraph verbatim text outside of the list (the list is therefore closed) regular paragraph after the list
produces:
point 1
point 2, first paragraph
point 2, second paragraph
verbatim text inside point 2
point 2, third paragraph
verbatim text outside of the list (the list is therefore closed)
regular paragraph after the list
You can use markup within text (except verbatim) to change the appearance of parts of that text. Out of the box, RDoc::Markup supports word-based and general markup.
Word-based markup uses flag characters around individual words:
*word* |
displays word in a bold font |
_word_ |
displays word in an emphasized font |
+word+ |
displays word in a code font |
General markup affects text between a start delimiter and an end delimiter. Not surprisingly, these delimiters look like HTML markup.
text |
displays text in a bold font |
text |
displays text in an emphasized font (alternate tag: ) |
<tt>text</tt> |
displays text in a code font (alternate tag: ) |
Unlike conventional Wiki markup, general markup can cross line boundaries. You can turn off the interpretation of markup by preceding the first character with a backslash (see Escaping Text Markup, below).
Links to starting with http:, https:, mailto:, ftp: or www. are recognized. An HTTP url that references an external image is converted into an inline image element.
Classes and methods will be automatically linked to their definition. For example, RDoc::Markup will link to this documentation. By default methods will only be automatically linked if they contain an _ (all methods can be automatically linked through the --hyperlink-all command line option).
Single-word methods can be linked by using the # character for instance methods or :: for class methods. For example, #convert links to convert. A class or method may be combined like RDoc::Markup#convert.
A heading inside the documentation can be linked by following the class or method by an @ then the heading name. RDoc::Markup@Links will link to this section like this: RDoc::Markup@Links. Spaces in headings with multiple words must be escaped with + like RDoc::Markup@Escaping+Text+Markup. Punctuation and other special characters must be escaped like CGI.escape.
Links can also be of the form label[url], in which case label is used in the displayed text, and url is used as the target. If label contains multiple words, put it in braces: {multi word label}[url]. The url may be an http:-type link or a cross-reference to a class, module or method with a label.
Links with the rdoc-ref: scheme will link to the referenced class, module, method, file, etc. If the referenced item is does not exist no link will be generated and rdoc-ref: will be removed from the resulting text.
Links starting with rdoc-label:label_name will link to the label_name. You can create a label for the current link (for bidirectional links) by supplying a name for the current link like rdoc-label:label-other:label-mine.
Links starting with link: refer to local files whose path is relative to the --op directory. Use rdoc-ref: instead of link: to link to files generated by RDoc as the link target may be different across RDoc generators.
Example links:
https://github.com/rdoc/rdoc<EMAIL_ADDRESS>{RDoc Documentation}[http://rdoc.rubyforge.org] {RDoc Markup}[rdoc-ref:RDoc::Markup]
Text markup can be escaped with a backslash, as in <tt>, which was obtained with \<tt>. Except in verbatim sections and between <tt> tags, to produce a backslash you have to double it unless it is followed by a space, tab or newline. Otherwise, the HTML formatter will discard it, as it is used to escape potential links:
* The \ must be doubled if not followed by white space: \\. * But not in \<tt> tags: in a Regexp, <tt>\S</tt> matches non-space. * This is a link to {ruby-lang}[www.ruby-lang.org]. * This is not a link, however: \{ruby-lang.org}[www.ruby-lang.org]. * This will not be linked to \RDoc::RDoc#document
generates:
The \ must be doubled if not followed by white space: \.
But not in <tt> tags: in a Regexp, \S matches non-space.
This is a link to ruby-lang
This is not a link, however: {ruby-lang.org}[www.ruby-lang.org]
This will not be linked to RDoc::RDoc#document
Inside <tt> tags, more precisely, leading backslashes are removed only if followed by a markup character (<*_+), a backslash, or a known link reference (a known class or method). So in the example above, the backslash of \S would be removed if there was a class or module named S in the current context.
This behavior is inherited from RDoc version 1, and has been kept for compatibility with existing RDoc documentation.
HTML will convert two/three dashes to an em-dash. Other common characters are converted as well:
em-dash:: -- or --- ellipsis:: ... single quotes:: 'text' or `text' double quotes:: "text" or ``text'' copyright:: (c) registered trademark:: (r)
produces:
em-dash |
– or — |
ellipsis |
… |
single quotes |
‘text’ or `text’ |
double quotes |
“text” or “text” |
copyright |
© |
registered trademark |
® |
Comment blocks can be written fairly naturally, either using # on successive lines of the comment, or by including the comment in a =begin/=end block. If you use the latter form, the =begin line must be flagged with an rdoc tag:
=begin rdoc Documentation to be processed by RDoc. ... =end
RDoc stops processing comments if it finds a comment line starting with -- right after the # character (otherwise, it will be treated as a rule if it has three dashes or more). This can be used to separate external from internal comments, or to stop a comment being associated with a method, class, or module. Commenting can be turned back on with a line that starts with ++.
## # Extract the age and calculate the date-of-birth. #-- # FIXME: fails if the birthday falls on February 29th #++ # The DOB is returned as a Time object. def get_dob(person) # ... end
Names of classes, files, and any method names containing an underscore or preceded by a hash character are automatically linked from comment text to their description. This linking works inside the current class or module, and with ancestor methods (in included modules or in the superclass).
Method parameter lists are extracted and displayed with the method description. If a method calls yield, then the parameters passed to yield will also be displayed:
def fred ... yield line, address
This will get documented as:
fred() { |line, address| ... }
You can override this using a comment containing ‘:yields: …’ immediately after the method definition
def fred # :yields: index, position # ... yield line, address
which will get documented as
fred() { |index, position| ... }
:yields: is an example of a documentation directive. These appear immediately after the start of the document element they are modifying.
RDoc automatically cross-references words with underscores or camel-case. To suppress cross-references, prefix the word with a \ character. To include special characters like "\n", you'll need to use two \ characters in normal text, but only one in <tt> text:
"\\n" or "<tt>\n</tt>"
produces:
“\n” or “\n”
Directives are keywords surrounded by “:” characters.
This directive prevents documentation for the element from being generated. For classes and modules, methods, aliases, constants, and attributes directly within the affected class or module also will be omitted. By default, though, modules and classes within that class or module will be documented. This is turned off by adding the all modifier.
module MyModule # :nodoc: class Input end end module OtherModule # :nodoc: all class Output end end
In the above code, only class MyModule::Input will be documented.
The :nodoc: directive, like :enddoc:, :stopdoc: and :startdoc: presented below, is local to the current file: if you do not want to document a module that appears in several files, specify :nodoc: on each appearance, at least once per file.
Stop and start adding new documentation elements to the current container. For example, if a class has a number of constants that you don’t want to document, put a :stopdoc: before the first, and a :startdoc: after the last. If you don’t specify a :startdoc: by the end of the container, disables documentation for the rest of the current file.
Forces a method or attribute to be documented even if it wouldn’t be otherwise. Useful if, for example, you want to include documentation of a particular private method.
Document nothing further at the current level: directives :startdoc: and :doc: that appear after this will not be honored for the current container (file, class or module), in the current file.
Only applicable to the initialize instance method. Normally RDoc assumes that the documentation and parameters for initialize are actually for the new method, and so fakes out a new for the class. The :notnew: directive stops this. Remember that initialize is private, so you won’t see the documentation unless you use the -a command line option.
Overrides the default argument handling with exactly these parameters.
## # :args: a, b def some_method(*a) end
Overrides the default yield discovery with these parameters.
## # :yields: key, value def each_thing &block @things.each(&block) end
Lines up to the next blank line or lines with a common prefix in the comment are treated as the method’s calling sequence, overriding the default parsing of method parameters and yield arguments.
Multiple lines may be used.
# :call-seq: # ARGF.readlines(sep=$/) -> array # ARGF.readlines(limit) -> array # ARGF.readlines(sep, limit) -> array # # ARGF.to_a(sep=$/) -> array # ARGF.to_a(limit) -> array # ARGF.to_a(sep, limit) -> array # # The remaining lines are documentation ...
Sections allow you to group methods in a class into sensible containers. If you use the sections ‘Public’, ‘Internal’ and ‘Deprecated’ (the three allowed method statuses from TomDoc) the sections will be displayed in that order placing the most useful methods at the top. Otherwise, sections will be displayed in alphabetical order.
Adds this item to the named section overriding the current section. Use this to group methods by section in RDoc output while maintaining a sensible ordering (like alphabetical).
# :category: Utility Methods # # CGI escapes +text+ def convert_string text CGI.escapeHTML text end
An empty category will place the item in the default category:
# :category: # # This method is in the default category def some_method # ... end
Unlike the :section: directive, :category: is not sticky. The category only applies to the item immediately following the comment.
Use the :section: directive to provide introductory text for a section of documentation.
Provides section introductory text in RDoc output. The title following :section: is used as the section name and the remainder of the comment containing the section is used as introductory text. A section’s comment block must be separated from following comment blocks. Use an empty title to switch to the default section.
The :section: directive is sticky, so subsequent methods, aliases, attributes, and classes will be contained in this section until the section is changed. The :category: directive will override the :section: directive.
A :section: comment block may have one or more lines before the :section: directive. These will be removed, and any identical lines at the end of the block are also removed. This allows you to add visual cues to the section.
Example:
# ---------------------------------------- # :section: My Section # This is the section that I wrote. # See it glisten in the noon-day sun. # ---------------------------------------- ## # Comment for some_method def some_method # ... end
Overrides the default markup type for this comment with the specified markup type. For ruby files, if the first comment contains this directive it is applied automatically to all comments in the file.
Unless you are converting between markup formats you should use a .rdoc_options file to specify the default documentation format for your entire project. See RDoc::Options@Saved+Options for instructions.
At the top of a file the :markup: directive applies to the entire file:
# coding: UTF-8 # :markup: TomDoc # TomDoc comment here ... class MyClass # ...
For just one comment:
# ... end # :markup: RDoc # # This is a comment in RDoc markup format ... def some_method # ...
See Markup@DEVELOPERS for instructions on adding a new markup format.
Include the contents of the named file at this point. This directive must appear alone on one line, possibly preceded by spaces. In this position, it can be escaped with a \ in front of the first colon.
The file will be searched for in the directories listed by the --include option, or in the current directory by default. The contents of the file will be shifted to have the same indentation as the ‘:’ at the start of the :include: directive.
Sets the title for the document. Equivalent to the --title command line parameter. (The command line parameter overrides any :title: directive in the source).
Equivalent to the --main command line parameter.
Take a block of text and use various heuristics to determine its structure (paragraphs, lists, and so on). Invoke an event handler as we identify significant chunks.
# File lib/rdoc/markup.rb, line 780 def initialize attribute_manager = nil @attribute_manager = attribute_manager || RDoc::Markup::AttributeManager.new @output = nil end
Parses str into an RDoc::Markup::Document.
# File lib/rdoc/markup.rb, line 750 def self.parse str RDoc::Markup::Parser.parse str rescue RDoc::Markup::Parser::Error => e $stderr.puts While parsing markup, RDoc encountered a #{e.class}:#{e}\tfrom #{e.backtrace.join "\n\tfrom "}---8<---#{text}---8<---RDoc #{RDoc::VERSION}Ruby #{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} #{RUBY_RELEASE_DATE}Please file a bug report with the above information at:https://github.com/rdoc/rdoc/issues raise end
Add to the sequences recognized as general markup.
# File lib/rdoc/markup.rb, line 797 def add_html(tag, name) @attribute_manager.add_html(tag, name) end
Add to other inline sequences. For example, we could add WikiWords using something like:
parser.add_special(/\b([A-Z][a-z]+[A-Z]\w+)/, :WIKIWORD)
Each wiki word will be presented to the output formatter via the accept_special method.
# File lib/rdoc/markup.rb, line 810 def add_special(pattern, name) @attribute_manager.add_special(pattern, name) end
Add to the sequences used to add formatting to an individual word (such as bold). Matching entries will generate attributes that the output formatters can recognize by their name.
# File lib/rdoc/markup.rb, line 790 def add_word_pair(start, stop, name) @attribute_manager.add_word_pair(start, stop, name) end
We take input, parse it if necessary, then invoke the output formatter using a Visitor to render the result.
# File lib/rdoc/markup.rb, line 818 def convert input, formatter document = case input when RDoc::Markup::Document then input else RDoc::Markup::Parser.parse input end document.accept formatter end
Generated with the Darkfish Rdoc Generator 2.


Preparation time
less than 30 mins
Cooking time
30 mins to 1 hour
Serves
Serves 4
Jo Pratt blends authentic ingredients into a quick homemade paste that forms the base of her Thai green chicken curry.
Heat the oil in a wok or large frying pan. Add the green curry paste and sugar and cook over a fairly high heat for about a minute, stirring with the lemongrass, if using. Reduce the heat slightly and stir in the chicken pieces and lime leaves or zest until coated in the paste. Add the coconut milk, fish sauce or soy sauce and bring to a simmer, cooking for 25-30 minutes until thickened slightly. Stir in the coriander and lime juice. Check for seasoning, adding more fish sauce or soy sauce if needed.
The curry is now best left to sit for a few minutes so the sauce becomes creamier. You will also taste the true flavours of the curry paste ingredients when it's slightly cooler. Serve with lots of fragrant Thai jasmine rice.


Qualifications
- Master's degree: Graduate School of Economics and Management, Tohoku University, Sendai, Japan (2017 –2019)
Thesis: "Trade and Economic Growth. Evidence from Trade Openness Through Regional Integration in Africa"
- Online MBA: Globis University, Japan (2017). Preparation in Strategy, Leadership and Cultural behavior
- Online in HR: OSHAcademy, US (2014). Professional Training Program for Safety Management at workplace
- Bachelor of Science: Faculty of Social and Management Sciences, Department of Economics and Management, University of Buea, Cameroon (2009-2012)
Thesis: "The Role of International Trade on Economic Growth of Cameroon"
ToolkitR, STATA, LaTeX, Google Cloud Services (Forms, Sheets, etc.), Microsoft PowerBI
Experience- Marketing Agent at Group Uni Pharma Inter Ltd (Douala-Cameroon, 2015-2016):
Implementation of Marketing strategies to uplift the revenue and increase the customer base.
- Weighbridge Operator at Bam International (Project of Quay Wall Construction, Limbe-Cameroon, 2014 for 7 months):
Collected and recorded material types and weights of trucks loaded with rocks from the quarry to the sea side (Quay Wall), as well fuel needed for operations. Ensured truck drivers’ effectiveness and efficiency by monitoring their speed, reporting to work and appropriate materials transported.
- Assistant Quality at Somainto Sarl (Cameroon, 2013 for 3 months):
An assistant quality in close collaboration with the chief engineer, responsible for issuing tests to be conducted on welded tanks and ensured welders effectiveness and efficiency by monitoring their number of defaults on welds and their punctuality to work.
Other activities- Organizing Secretary: African Association of Miyagi (AFAM), Japan (2017-10 - )
- A Lead Singer: KUVUKI Group, AFAM, Japan (2017-04 - )
- R&D department: KAKEHASHI Africa, Japan, Japan (2017-03 - )
AwardsAfrican Business Education (ABE) initiative scholarship by JICA: 2016-2019
LanguagesEnglish, French, Japanese
References available upon request


Build bands easily...
Throw away your spreadsheet. Forget about endless phone calls, e-mails, and text messages. Check availability of individual musicians, track replies, communicate gig details, confirm your roster, execute contracts, and distribute sheet music with a few clicks. Concert Talent enables you to support important musical projects with minimal fuss.
Find real pros fast...
The freelance music biz is more social than ever, so a reputation for delivering quality talent is important. When auditioning new talent isn't possible, a recommendation from a trusted friend can make all the difference. Cut through the hype of press kits and online profiles; find artists your colleagues confirm can get the job done.
Book groups worldwide...
Professional musicians are always on the go. Whether you need to plug into the circle of first-call talent in a new town, or just save money by contracting players local to the next venue on a national tour, we've got you covered with the tools you need to quickly expand your roster virtually anywhere on the planet.
Hassle-free paydays...
Let's face it: collecting 1099 info, stuffing envelopes. mailing checks, and paying union dues is a pain. We're working on features that make taking care of your musicians and reconciling your ledger even easier than hiring them. You'll never have to say, "It's in the mail" to another colleague again.


Bangladesh government has called for a migrant worker's repatriation from Saudi Arabia after her video alleging sexual abuse highlighted the exploitation faced by Asians working abroad.
In a Facebook video which has been shared thousands of times and prompted protests in Dhaka against workers' conditions, Sumi Akter alleged "merciless sexual assaults" by her Saudi employers.
"I perhaps won't live longer. Please save me. They locked me up for 15 days and barely gave me any food. They burned my hands with hot oil," the 25-year-old said.
More:
- Abused Bangladeshi domestic workers struggle for justice at home
- Up to $10,000: What migrant workers pay for a job in GCC
- In Kerala, the glittering Gulf's appeal is losing shine
On Sunday, the government called on the state-run manpower exporting agency to bring Akter back home "as soon as possible".

Since 1991, some 300,000 Bangladeshi women have travelled to the Gulf nation for work, according to the ministry of expatriates' welfare.
Those workers account for the largest amount of remittance sent back to Bangladesh.
Government spokesman Atiqur Rahman said Dhaka would crack down on rogue recruitment firms amid allegations that they abused female workers and sold them to other brokers.
Foreign Minister AK Abdul Momen had said on Thursday the government would not ban women from going to Saudi Arabia for work.
"Saudi Arabia admitted some people are being victimised. But that is happening for a few handfuls of people. The Saudi government isn't making them victims," he told reporters.
Akter's video comes after the body of migrant worker Nazma Begum was repatriated in late October.
The 42-year-old Begum had called her son Rajib Hossain repeatedly before her death, alleging torture and asking to be rescued, Hossain told AFP, adding that she died of an untreated illness.
Both women said they were promised hospital janitor jobs but were tricked into being household maids.
Millions of Asians travel to the Gulf to work, according to Bangladesh's government, and human rights groups say many suffer exploitation and abuses with no channels for redress.
Last month, Bangladeshi migrant rights group Ovibashi Karmi Unnayan Program said 61 percent of 110 women they interviewed who returned home, many from Saudi Arabia, claimed they were physically abused.
Some 14 percent said they were sexually abused, the group added.
Dhaka-based BRAC, one of the world's largest charities, said this year alone, the bodies of 48 female workers were brought back from Saudi Arabia.


Register a new membership
(Citation from Wikipedia)
Terms of service (also known as terms of use and terms and conditions, commonly abbreviated as TOS or ToS and ToU) are rules by which one must agree to abide in order to use a service. Terms of service can also be merely a disclaimer, especially regarding the use of websites.
Usage
The Terms of Service Agreement is mainly used for legal purposes by companies which provide software or services, such as browsers, e-commerce, search engines, social media, and transport services.
A legitimate terms-of-service agreement is legally binding and may be subject to change. Companies can enforce the terms by refusing service. Customers can enforce by filing a suit or arbitration case if they can show they were actually harmed by a breach of the terms. There is a heightened risk of data going astray during corporate changes, including mergers, divestitures, buyouts, downsizing, etc., when data can be transferred improperly.
I already have a membership


- Show all
- Scholarships
- Grants
-
US Bank Scholarship Program
Scholarships
-
Bill and Melinda Gates Foundation
Grants
-
Federal Student Aid
Grants
-
Quest Bridge
Scholarships
-
National Scholarship Providers
Scholarships
-
U.S. Department of Health & Human Services
Grants
-
Kalamazo Community Foundation
Grants
-
Government Grants and Loans
Grants
-
Wong: Helen and L.S. Wong Memorial Scholarship
Scholarships
-
Kalamazo Community Foundation
Grants
-
Kalamazo Community Foundation
Grants
-
National Endowment For The Arts
Grants
-
Kalamazo Community Foundation
Grants
-
Kalamazo Community Foundation
Grants


A visual identity allows an organization to be instantly recognizable. Comprised of their logo, typeface, and colours, it is applied when creating external or internal communications. At universities, staff create visualizations that adhere to the colour palette specified by their institution’s visual identity guidelines. For example, on the Students and Alumni page of UBC Master of Data Science website, the visualizations all adhere to the colour palette specified by UBC’s visual identity guideline.
This R package allows users to apply university-specific themes to ggplot2 objects. This package currently supports the official colour palettes of four institutions belonging to the U15 Group of Canadian Research Universities: the University of Alberta, the University of British Columbia, McGill University, and the University of Toronto. In the future, we hope to extend this package to support the visual identities of all universities in the association.
The hueniverrrsity package fits into the R ecosystem with other R packages that allow users to change the theme of ggplot2 objects. These types of packages allow general aesthetic theme changes or specific theme changes for a purpose. One of the most common packages of this type is ggthemes, which allows users to select and apply different general themes to ggplot2 objects. Our package will be different from ggthemes since the goal of the change in plot theme is to adhere to university-specific colour palettes, rather than to generally change the colour and appearance of plots.
You can install the development version of hueniverrrsity from GitHub with:
# install.packages("devtools")
devtools::install_github("UBC-MDS/hueniverrrsity")
Start by importing the following packages:
theme_alberta()
Input:
colour_use
: fill
or colour
colour_use = colour
for geom_point()
and geom_line()
colour_use = fill
for geom_boxplot()
, geom_bar()
, geom_violin()
and geom_histogram()
colour_palette
: alpha
, beta
, gamma
or delta
Available palettes:
alpha
beta
gamma
delta
Output:
Examples:
# Create scatter plot
a1 <- ggplot(data=mtcars, aes(x = hp, y = mpg, colour = as.factor(cyl))) +
geom_point(size = 3, alpha = 0.8) +
theme_alberta('colour', 'beta')
# Create density plot
a2 <- ggplot(data = mtcars, aes(x = hp, fill = as.factor(cyl))) +
geom_density(alpha = 0.8) +
theme_alberta('fill', 'delta')
ggarrange(a1, a2, ncol=2, common.legend = TRUE)
theme_mcgill()
Input:
colour_use
: fill
or colour
colour_use = colour
for geom_point()
and geom_line()
colour_use = fill
for geom_boxplot()
, geom_bar()
, geom_violin()
and geom_histogram()
Available palette:
Output:
Examples:
# Create scatter plot
m1 <- ggplot(data = mtcars, aes(x = hp, y = mpg, colour = as.factor(cyl))) +
geom_point(size = 3, alpha = 0.8) +
theme_mcgill('colour')
# Create density plot
m2 <- ggplot(data = mtcars, aes(x = hp, fill = as.factor(cyl))) +
geom_density(alpha=0.8) +
theme_mcgill('fill')
ggarrange(m1, m2, ncol=2, common.legend = TRUE)
theme_toronto()
Input:
colour_use
: fill
or colour
colour_use = colour
for geom_point()
and geom_line()
colour_use = fill
for geom_boxplot()
, geom_bar()
, geom_violin()
and geom_histogram()
colour_palette
: vibrant
, cool
or awards
Available palettes:
vibrant
cool
awards
Output:
Examples:
# Create scatter plot
t1 <- ggplot(data = mtcars, aes(x = hp, y = mpg, colour = as.factor(cyl))) +
geom_point(size = 2.5) +
theme_toronto('colour', 'vibrant')
# Create density plot
t2 <- ggplot(data = mtcars, aes(x = hp, fill = as.factor(cyl))) +
geom_density(alpha = 0.8) +
theme_toronto('fill', 'awards')
ggarrange(t1, t2, ncol=2, common.legend = TRUE)
theme_ubc()
Input:
colour_use
: fill
or colour
colour_use = colour
for geom_point()
and geom_line()
colour_use = fill
for geom_boxplot()
, geom_bar()
, geom_violin()
and geom_histogram()
Available palette:
Output:
Examples:
# Create scatter plot
u1 <- ggplot(data = mtcars, aes(x = hp, y = mpg, colour = as.factor(cyl))) +
geom_point(size = 2.5) +
theme_ubc('colour')
# Create density plot
u2 <- ggplot(data = mtcars, aes(x = hp, fill = as.factor(cyl))) +
geom_density(alpha=0.8) +
theme_ubc('fill')
ggarrange(u1, u2, ncol=2, common.legend = TRUE)


class Constants
extends java.lang.Object
| Constructor | Description |
|---|---|
Constants() |
| Modifier and Type | Method | Description |
|---|---|---|
static double |
random(double min,
double max) |
Generates random double in [min, max].
|
public static final int GRAPHICS_WIN_WIDTH
public static final int GRAPHICS_WIN_HEIGHT
public static final int GRAPHICS_FRAME_DELAY
public static final int COIN_TEXT_SIZE
public static final int COIN_TEXT_X
public static final int COIN_TEXT_Y
public static final int COIN_TEXT_COLOR_R
public static final int COIN_TEXT_COLOR_G
public static final int COIN_TEXT_COLOR_B
public static final int PRICE_TEXT_SIZE
public static final int PRICE_TEXT_COLOR_R
public static final int PRICE_TEXT_COLOR_G
public static final int PRICE_TEXT_COLOR_B
public static final int GUPPY_PRICE_TEXT_X
public static final int GUPPY_PRICE_TEXT_Y
public static final int PELLET_PRICE_TEXT_X
public static final int PELLET_PRICE_TEXT_Y
public static final int PIRANHA_PRICE_TEXT_X
public static final int PIRANHA_PRICE_TEXT_Y
public static final int SNAIL_PRICE_TEXT_X
public static final int SNAIL_PRICE_TEXT_Y
public static final int EGG_PRICE_TEXT_X
public static final int EGG_PRICE_TEXT_Y
public static final int EGG_COUNT_TEXT_SIZE
public static final int EGG_COUNT_TEXT_X
public static final int EGG_COUNT_TEXT_Y
public static final int EGG_COUNT_TEXT_COLOR_R
public static final int EGG_COUNT_TEXT_COLOR_G
public static final int EGG_COUNT_TEXT_COLOR_B
public static final int BUY_GUPPY_BUTTON_X_START
public static final int BUY_GUPPY_BUTTON_X_END
public static final int BUY_GUPPY_BUTTON_Y_START
public static final int BUY_GUPPY_BUTTON_Y_END
public static final int BUY_PIRANHA_BUTTON_X_START
public static final int BUY_PIRANHA_BUTTON_X_END
public static final int BUY_PIRANHA_BUTTON_Y_START
public static final int BUY_PIRANHA_BUTTON_Y_END
public static final int BUY_SNAIL_BUTTON_X_START
public static final int BUY_SNAIL_BUTTON_X_END
public static final int BUY_SNAIL_BUTTON_Y_START
public static final int BUY_SNAIL_BUTTON_Y_END
public static final int BUY_EGG_BUTTON_X_START
public static final int BUY_EGG_BUTTON_X_END
public static final int BUY_EGG_BUTTON_Y_START
public static final int BUY_EGG_BUTTON_Y_END
public static final int MAIN_START_BUTTON_X_START
public static final int MAIN_START_BUTTON_X_END
public static final int MAIN_START_BUTTON_Y_START
public static final int MAIN_START_BUTTON_Y_END
public static final int WIN_START_BUTTON_X_START
public static final int WIN_START_BUTTON_X_END
public static final int WIN_START_BUTTON_Y_START
public static final int WIN_START_BUTTON_Y_END
public static final int LOSE_START_BUTTON_X_START
public static final int LOSE_START_BUTTON_X_END
public static final int LOSE_START_BUTTON_Y_START
public static final int LOSE_START_BUTTON_Y_END
public static final int GAME_INITIAL_COIN
public static final int GAME_SCREEN_LEFT_PADDING
public static final int GAME_SCREEN_RIGHT_PADDING
public static final int GAME_SCREEN_TOP_PADDING
public static final int GAME_SCREEN_BOTTOM_PADDING
public static final int MAX_LEVEL
public static final int EGG_PRICE
public static final double RANDOM_MOVE_INTERVAL
public static final double COIN_MOVE_SPEED
public static final double COIN_DELETION_INTERVAL
public static final int COIN_GOLD_THRESHOLD
public static final int COIN_CLICK_AREA_WIDTH
public static final int COIN_CLICK_AREA_HEIGHT
public static final int GUPPY_FOOD_THRES
public static final int GUPPY_PRICE
public static final double GUPPY_EAT_RADIUS
public static final double GUPPY_FULL_INTERVAL
public static final double GUPPY_HUNGER_INTERVAL
public static final double GUPPY_MOVE_SPEED
public static final double GUPPY_COIN_INTERVAL
public static final double GUPPY_COIN_MULTIPLIER
public static final double PELLET_SPEED
public static final int PELLET_PRICE
public static final int PIRANHA_FOOD_THRES
public static final int PIRANHA_PRICE
public static final double PIRANHA_EAT_RADIUS
public static final double PIRANHA_FULL_INTERVAL
public static final double PIRANHA_HUNGER_INTERVAL
public static final double PIRANHA_MOVE_SPEED
public static final int SNAIL_PRICE
public static final double SNAIL_SPEED
public static final double SNAIL_EAT_RADIUS
public static final double PROGRESS_PERIOD
public static final double GUPPY_TURN_PROGRESS_INCREMENT_TIME
public static final double GUPPY_MOVE_PROGRESS_INCREMENT_TIME
public static final double GUPPY_DEAD_PROGRESS_INCREMENT_TIME
public static final double GUPPY_EAT_PROGRESS_INCREMENT_TIME
public static final double PIRANHA_TURN_PROGRESS_INCREMENT_TIME
public static final double PIRANHA_MOVE_PROGRESS_INCREMENT_TIME
public static final double PIRANHA_DEAD_PROGRESS_INCREMENT_TIME
public static final double PIRANHA_EAT_PROGRESS_INCREMENT_TIME
public static final double SNAIL_TURN_PROGRESS_INCREMENT_TIME
public static final double SNAIL_MOVE_PROGRESS_INCREMENT_TIME
public static final double PELLET_MOVE_PROGRESS_INCREMENT_TIME
public static final double COIN_PROGRESS_INCREMENT_TIME


SeaThePollution
Home
Map
Information
Marine Life
Contact Us
Sign-In
Sign-In
x
Sign-Up
You don't have an account?
x
You already have an account?
Sign-In
Sign-Up


The HPLAB at Korea University investigates human cognitive processes related to cognitive control, response selection, visual selective attention, and emotion. We believe that understanding the control mechanisms is important because human beings always perceive information from environment and make responses by their actions. Therefore, the ability to flexibly adjust mental set is one of the most important processes for human. In addition, as emotional process modulates our attentional process, we investigate interactions between attention and emotion.
To accomplish our research goals, we use mainly behavioral measures and psychophysiological measures including electrodermal activity (EDA), electrocardiography (ECG) and electroencephalography (EEG). In these days, we analyze EEG data with machine learning methods (MVPA) to decode human brain activities. Furthermore, we also use functional magnetic resonance imaging (fMRI) to study cognitive control and visual selective attention. In collaboration with our colleagues, we hope to understand human brain activities especially in cognitive control and attentional processes.


Properties attached bind configure element unbind viewModel Methods bootstrap boundTo create dispose inView manuallyHandleLifecycle waitForElement waitForElements withResources


You have a request for revoke proposal from <> for the label <>
Note: all data encrypted under this label will be inaccessible for everyone if you approve this request.
If you have not triggered this request, please cancel it.


Lunsford, a sophomore studying mathematics, was first introduced to vaping after graduating highschool in 2018. He picked up a landscaping job during the summer before his freshman year, where he was surrounded by coworkers who used chewing tobacco, smoked cigarettes and used electronic cigarettes.
“Honestly, it made work easier,” Lunsford said. “Got me addicted real quick.”
He bought his first Juul soon after, figuring that his lungs would be able to take the abuse. At the height of his addiction, he was usually hitting his Juul 20-25 times a day and much more often during particularly stressful moments.
“Governor DeWine came into office, and the first thing he said was ‘I hate tobacco, and we’re going to raise the age to buy cigarettes to 21 because I want kids not to start.’ The world’s best intention. But the road to hell is paved with such intentions,””-Dr. Rob Crane, President of Tobacco 21
He has tried quitting several times, attempting to give up his habit cold turkey or only smoking in social settings. He’s seen limited success, making it a month or so at a time without using a vape.
Since then, Lunsford has been using a different device because his Juul habit had become too expensive, he said. He still has plans to quit in the future.
He is just one of the 3.6 million young people who have become addicted to nicotine during middle school and high school during the past two years, according to the Preventing Tobacco Addiction Foundation.
The foundation, also known as the Tobacco 21 project, has been working to decrease the use of tobacco by minors for over two decades. Around 2005, the project began working with data from Needham, Massachusetts, a small suburb outside Boston, which had seen steep reductions in tobacco use in minors after increasing the legal age limit to 21.
In 2015, the National Institute of Health found that about 4.2 million years of life would have been saved among people under 18 if the age limit was raised to 21 nationally. Tobacco 21 played a role in the push for Hawaii to raise the legal age for purchasing tobacco products to 21 in 2016, the first state in the country to do so. Then Juul came along.
“Juul, alone, managed to knock back almost two decades of progress in youth nicotine addiction,” Dr. Rob Crane, president of Tobacco 21, said.
First introduced in 2015, the sleek, concealable devices make up almost 75% of the current e-cigarette market, according to Bloomberg. Juul markets itself as an alternative for adult cigarette smokers. However, Juul also launched a savvy social media campaign, paying influencers to use Juuls on Snapchat, Instagram and other social media outlets to thousands of followers, Crane said. The original fruity flavors on the market also helped to rope in young users, according to a previous Post report.
Altria Group Inc., which sells Marlboro cigarettes in the U.S., acquired a 35% stake in Juul in February. The deal valued the vaping business at $38 billion, turning Juul’s two founders into billionaires.
Meanwhile, the Surgeon General estimates that one in five high school students and one in 20 middle school students currently use e-cigarettes. The Center for Disease Control estimates that of the 3.6 million young people currently using e-cigarettes, about 30% of them will eventually switch over to smoking traditional cigarettes, which, in terms of addiction, is like jumping from oxycodone to heroin, Crane said.
In 2018, Tobacco 21 found that almost 28% of all Ohio State University freshmen had used an e-cigarette before, and over one-fourth of freshmen had used a Juul specifically. The CDC also found that most adults who do use e-cigarettes to stop smoking are instead continuing to use both products.
In April, the Food and Drug Administration announced that it had launched an investigation into over a hundred cases of people who have suffered seizures after vaping. The FDA, CDC and other public health organizations also have an ongoing investigation regarding an outbreak of severe lung disease associated with e-cigarette use.
But despite a significant increase in the number of young people using tobacco products, Tobacco 21 has been very successful in recent years. Almost 500 cities and counties and 18 states have raised the age limit, including Cleveland, Columbus and Cincinnati, and — following Governor Mike DeWine’s 2019 state budget being passed — the entire state of Ohio.
Juul actually supports the push for 21 despite its widespread use by young people. After being pressured by the FDA, Juul sent representatives across the country to lobby for states to raise the age limit.
While this may seem like a positive move, it may actually be harmful for the movement, Crane said. Due to preemption of state law over local ones, Juul is able to get state laws passed in a way that would ensure retailers would almost never get caught selling to underage consumers, he said.
“In Virginia, Arkansas and Utah, they stopped any possibility of a city coming in and overriding Juul, or banning flavors, or doing anything to restrict sales near schools or whatever other things, which might be done to reduce youth usage,” he said. “They made sure that no one was ever going to enforce age 21 because you put it in the hands of the police without giving them any money.”
“This is … essentially a move that will likely kill most mom and pop vape shops and companies that responsibly and ethically produce their juice in the United States,”-James Wanke, general manager of Silver Serpent Exotic Gifts in Athens
While Ohio has no state preemption for local tobacco laws, Crane, who lives in Columbus, still believes that the state passed a terrible bill.
“Governor DeWine came into office, and the first thing he said was ‘I hate tobacco, and we’re going to raise the age to buy cigarettes to 21 because I want kids not to start.’ The world’s best intention. But the road to hell is paved with such intentions,” Crane said.
Crane said Ohio’s new law will be difficult to enforce.
“What they did was simply cross out age 18 and set it to 21 and had the police do the enforcement but no required enforcement,” he said. “And there is no real money designated for this effort.”
Tobacco 21 would like to keep pushing to change local tobacco laws in Ohio, but once a state law has been passed, the political will “goes out the balloon” for local laws, Crane said.
But even though the state law prohibits the sale of tobacco products to those under 21 in Ohio, many tobacco shops will either skirt the law or be unable to identify fake IDs used by many college students, Crane said. He has never seen a tobacco shop go out of business as a result of a change in the age limit.
Some government agencies occasionally send out “underage decoys” to tobacco retailers to see how often they sell to young people. For instance, Columbus has issued fines to retailers who sold to these “decoys,” and the city is currently undergoing its third wave of inspections.
Some tobacco retailers are trying to fight back against the new laws. James Wanke, general manager of Silver Serpent Exotic Gifts in Athens, said that while his shop will follow the new law when it takes effect in October, raising the age limit could prove to be a death blow to smaller retailers like his.
“This is … essentially a move that will likely kill most mom and pop vape shops and companies that responsibly and ethically produce their juice in the United States,” Wanke said in an email. “To everyone here at Silver Serpent, many of us whom have been vaping since the industry was formed, this is a battle for the soul of the vaping community as a whole … so I really hate to see it go down this way and for big tobacco to walk away with the win.”
As someone who is under 21 and addicted to nicotine, Lunsford has mixed feelings about the raised age limit.
“I understand the risks. And I'm living it right now, being addicted and having to deal with the problems that come along with that,” Lunsford said. “At 18, (you) can sign up and die for your country but not vape. It doesn’t seem right. It seems very consistent.”
At the moment, Crane and Tobacco 21 are occupied with four different laws at the federal level. He spends at least one day a week in Washington D.C., trying to get the federal government to pass better tobacco laws as well. The FDA, which enforces federal tobacco laws, currently sets the legal sale age of tobacco to 21.
Youth tobacco use is personal to Crane. His nephew, who lives with him in Columbus, is addicted to his Juul.
“I said to him, ‘You can’t stay with us if you’re going to Juul.’ Good kid. (But) it’s tough. It’s really hard.”
Lunsford would like to get back into running but said e-cigarettes have taken a toll on his health.
“I had decently strong lungs before I started. So I thought, ‘It’ll be fine. My lungs can take it.’ Had I only done it at work or something, but then I was doing it day to day, and it really took a toll. Now when I go out on a run, I can definitely tell the difference. I just don’t have the lung capacity that I used to.”


Variables
Prerequisites
- Welcome Quest
- Power of Puppet Quest
- Resources Quest
- Mainfest Quest
Quest Objectives
- Learn how to make Puppet manifests more flexible using variables
- Learn how to interpolate variables in manifests
- Understand how facts can be used
Getting Started
Manifests contain instructions for automating tasks related to managing resources. Now it's time to learn how to make manifests more flexible. In this quest you will learn how to include variables, interpolate variables, and use Facter facts in your manifests in order to increase their portability and flexibility. When you're ready to get started, type the following command:
quest --start variables
Variables
The green reed which bends in the wind is stronger than the mighty oak which breaks in a storm.
-Confucius
Puppet can be used to manage configurations on a variety of different operating systems and platforms. The ability to write portable code that accomodates various platforms is a significant advantage in using Puppet. It is important that you learn to write manifests in such a way that they can function in different contexts. Effective use of variables is one of the fundamental methods you will use to achieve this.
If you've used variables before in some other programming or scripting language, the concept should be familiar. Variables allow you to assign data to a variable name in your manifest and then use that name to reference that data elsewhere in your manifest. In Puppet's syntax, variable names are prefixed with a $
(dollar sign). You can assign data to a variable name with the =
operator. You can also use variables as the value for any resource attribute, or as the title of a resource. In short, once you have defined a variable with a value you can use it anywhere you would have used the value or data.
Unlike resource declarations, variable assignments are parse-order dependent. This means that you must assign a variable in your manifest before you can use it.
The following is a simple example of assigning a value, which in this case, is a string, to a variable.
$myvariable = "look, data!\n"
Also...
In addition to directly assigning data to a variable, you can assign the result of any expression or function that resolves to a normal data type to a variable. This variable will then refer to the result of that statement.
Task 1 :
Using Puppet, create the file /root/pangrams/fox.txt
with the specified content.
Create a new manifest in your home directory.
nano ~/pangrams.pp
HINT: Refer to the Manifest Quest if you're stuck.
Type the following Puppet code into the pangrams.pp
manifest:
$pangram = 'The quick brown fox jumps over the lazy dog.'
file {'/root/pangrams':
ensure => directory,
}
file {'/root/pangrams/fox.txt':
ensure => file,
content => $pangram,
}
Now that we have a manifest, let's test it on the VM.
Remember to validate the syntax of the file, and to simulate the change using the -noop
flag before you use puppet apply
to make the required change on the system.
Excellent! Take look at the file to see that the contents have been set as you intended:
cat /root/pangrams/fox.txt
A pangram is a sentence that uses every letter of the alphabet. A perfect pangram uses each letter only once.
The string assigned to the $pangram
variable was passed into your file resource's content
attribute, which in turn told Puppet what the content of the /tmp/pangram.txt
file should exist.
Variable Interpolation
The extra effort required to assign variables starts to show its value when you begin to incorporate variables into your manifests in more complex ways.
Variable interpolation allows you to replace occurences of the variable with the value of the variable. In practice this helps with creating a string, the content of which contains another string which is stored in a variable. To interpolate a variable in a string, the variable name is preceded by a $
and wrapped in curly braces (${var_name}
).
The braces allow puppet parser
to distinguish between the variable and the string in which it is embedded. It is important to remember, a string that includes an interpolated variable must be wrapped in double quotation marks ("..."
), rather than the single quotation marks that surround an ordinary string.
"Variable interpolation is ${adjective}!"
Wrapping a string without any interpolated variables in double quotes will still work, but it goes against conventions described in the Puppet Labs Style Guide.
Task 2 :
Create a file called perfect_pangrams. We will use variable substitution and interpolation in doing this.
Now you can use variable interpolation to do something more interesting. Go ahead and create a new manifest called perfect_pangrams.pp
.
nano ~/perfect_pangrams.pp
HINT: Refer to the Manifest Quest if you're stuck
Type the following Puppet code into the perfect_pangrams.pp
manifest:
$perfect_pangram = 'Bortz waqf glyphs vex muck djin.'
$pgdir = '/root/pangrams'
file { $pgdir:
ensure => directory,
}
file { "${pgdir}/perfect_pangrams":
ensure => directory,
}
file { "${pgdir}/perfect_pangrams/bortz.txt":
ensure => file,
content => "A perfect pangram: \n${perfect_pangram}",
}
Once you have create the perfect_pangrams.pp
file, enforce it using the appropriate puppet apply
command, but not before you verify that the syntax is correct and have tried simulating it first. Refer to the Manifests quest if you need to refresh you memory on how to apply a manifest.
Here, the $pgdir
variable resolves to '/root/pangrams'
, and the interpolated string "${pgdir}/perfect_pangrams"
resolves to '/root/pangrams/perfect_pangrams'
. It is best to use variables in this way to avoid redundancy and allow for data separation in the directory and filepaths. If you wanted to work in another user's home directory, for example, you would only have to change the $pgdir
variable, and would not need to change any of your resource declarations.
Have a look at the bortz.txt
file:
cat /root/pangrams/perfect_pangrams/bortz.txt
You should see something like this, with your pangram variable inserted into the file's content string:
A perfect pangram:
Bortz waqf glyphs vex muck djin.
What this perfect pangram actually means, however, is outside the scope of this lesson!
Facts
Get your facts first, then distort them as you please.
-Mark Twain
Puppet has a bunch of built-in, pre-assigned variables that you can use. Remember using the Facter tool when you first started? The Facter tool discovers information about your system and makes it available to Puppet as variables. Puppet’s compiler accesses those facts when it’s reading a manifest.
Remember running facter ipaddress
? told you your IP address. What if you wanted to turn facter ipaddress
into a variable? You guessed it. It would look like this: $::ipaddress
as a stand-alone variable, or like this:
${::ipaddress}
when interpolated in a string.
The ::
in the above indicates that we always want the top-scope variable, the global fact called ipaddress
, as opposed to, say a variable called ipaddress
you defined in a specific manifest.
In the Conditions Quest, you will see how Puppet manifests can be designed to perform differently depending on facts available through facter
. For now, let's play with some facts to get a feel for what's available.
Task 3 :
We will write a manifest that will interpolate facter variables into a string assigned to the $message
variable. We can then use a notify
resource to post a notification when the manifest is applied. We will also declare a file resource. We can use the same $string
to assign our interpolated string to this file's content parameter.
Create a new manifest with your text editor.
nano ~/facts.pp
HINT: Refer to the Manifest Quest if you're stuck
Type the following Puppet code into the facts.pp
manifest:
$string = "Hi, I'm a ${::osfamily} system and I have been up for ${::uptime} seconds."
notify { 'info':
message => $string,
}
file { '/root/message.txt':
ensure => file,
content => $string,
}
Once you have created the facts.pp file, enforce it using the appropriate puppet apply
command, after verifying that the syntax is correct.
You should see your message displayed along with Puppet's other notifications. You can also use the cat
command or a text editor to have a look at the message.txt
file with the same content.
cat /root/message.txt
As you can see, by incorporating facts and variables, and by using variable interpolation, you can add more functionality with more compact code. In the next quest we will discuss conditional statements that will provide for greater flexibility in using Puppet.
Review
In this quest you've learned how to take your Puppet manifests to the next level by using variables. There are even more levels to come, but this is a good start. We learned how to assign a value to a variable and then reference the variable by name whenever we need its content. We also learned how to interpolate variables, and how Facter facts are global variables available for you to use.
In addition to learning about variables, interpolating variables, and facts, you also gained more hands-on learning with constructing Puppet manifests using Puppet's DSL. We hope you are becoming more familar and confident with using and writing Puppet code as you are progressing.
Looking back to the Power of Puppet Quest, can you identify where and how variables are used in the lvmguide
class?


|
flippy
a c++20 package for dynamically triangulated membrane simulations.
|
#include <Triangulation.hpp>
Static Public Member Functions | |
| static Index | plus_one (Index j, Index ring_size) |
| static Index | minus_one (Index j, Index ring_size) |
Public Attributes | |
| Index | j_m_1 {VERY_LARGE_NUMBER_} |
| neighbor j+1 | |
| Index | j_p_1 {VERY_LARGE_NUMBER_} |
| neighbor j-1 | |
A helper struct; makes addition and subtraction on a ring easier. Each fp::Node stores its next neighbors in a vector Node.nn_ids, where the adjacent members in a vector are also next neighbors of each other. This struct provides a safe way to always access the next or previous member of the nn_ids vector, even if a wraparound is necessary.
| Index | type that will be used for all integer numbers inside this class/struct. Any data type that satisfies the indexing_number concept is allowed, for example, unsigned int . |
|
inlinestatic |
| j | index of the j-th next neighbor |
| ring_size | corresponds to the number of elements of Node.nn_ids |
j+1
if j < ring_size - 1
and 0
otherwise. I.e., if j
is the index of Node.nn_ids, its next neighbor will be stored in j+1
element, unless j
is the last element, then its next neighbor will be stored in the 0th element.
|
inlinestatic |
| j | index of the j-th next neighbor |
| ring_size | corresponds to the number of elements of Node.nn_ids |
j-1
if j > 0
and ring_size - 1
otherwise. I.e., if j
is the index of Node.nn_ids, its previous next neighbor will be stored in j-1
element, unless j
is the 0th element, then its previous next neighbor will be stored in the last element.


ORIGAMI TYPOGRAPHY
Zhiyu Bai © 2016
I was inspired by a technique of paper folding called 折り紙 (origami) from Japan. As I found origami and typography possess some common features - they are both shaping the space with with shapes and proportion. So I design a set of origami typography for display and apply it in a kinetic webpage poster.
Handiworks like origami possess a nostalgic spirit of humanism and love. Dating back to 1680, this traditional decoration is used in ceremonies and entertainment activities in the oriental world. On the other hand, its pattern and construction illustrates the logical aethetics of mathematics. It is a combination of two poles of knowledge and the intuition, a cohension of the mystery of nature and the intellegence of human.
Here, we celebrate the minimalistic and dynamic attributes of origami through typography on digital media. Its revival on screen-based interface, I believe, provides inspirations for the visual as well as the tangible interactions in terms of design and programming.


Suggested Initial Rating
You can set your initial rating as you like. Following list is suggestion from me, and its likely to be updated often.
- KR Grandmasters ~ 2550
- AM Grandmasters ~ 2400
- KR Masters ~ 2250
- AM Masters ~ 2150
- KR Diamond ~ 2100
- AM Diamond ~ 1950
- KR Platinum ~ 1800
- AM Platinum ~ 1700
- KR Gold ~ 1600
- AM Gold ~ 1500
- KR Silver ~ 1400
- AM Silver ~ 1300
- KR/AM Bronze ~ 1200
- Novice ~ 1000
- I will never use my keyboard ~ 500