|
Connected Home over IP
672cf7684
|
Provides a generic implementation of ThreadStackManager features that works on FreeRTOS platforms. More...
#include <include/platform/ThreadStackManager.h>
Protected Member Functions | |
| CHIP_ERROR | _StartThreadTask (void) |
| void | _LockThreadStack (void) |
| bool | _TryLockThreadStack (void) |
| void | _UnlockThreadStack (void) |
| CHIP_ERROR | DoInit () |
| void | SignalThreadActivityPending () |
| BaseType_t | SignalThreadActivityPendingFromISR () |
Protected Attributes | |
| SemaphoreHandle_t | mThreadStackLock |
| TaskHandle_t | mThreadTask |
Provides a generic implementation of ThreadStackManager features that works on FreeRTOS platforms.
This template contains implementations of select features from the ThreadStackManager abstract interface that are suitable for use on FreeRTOS-based platforms. It is intended to be inherited, directly or indirectly, by the ThreadStackManagerImpl class, which also appears as the template's ImplClass parameter.
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |
|
protected |


| Interface | Description |
|---|---|
| BatchedRemoteIterator.BatchedEntries<E> | |
| BlockStoragePolicySpi |
A storage policy specifies the placement of block replicas on specific
storage types.
|
| ByteBufferReadable |
Implementers of this interface provide a read API that writes to a
ByteBuffer, not a byte[].
|
| CanSetDropBehind | |
| CanSetReadahead | |
| CanUnbuffer |
FSDataInputStreams implement this interface to indicate that they can clear
their buffers on request.
|
| DelegationTokenRenewer.Renewable |
The renewable interface used by the renewer.
|
| FsConstants |
FileSystem related constants.
|
| GetSpaceUsed | |
| GlobalStorageStatistics.StorageStatisticsProvider |
A callback API for creating new StorageStatistics instances.
|
| PathFilter | |
| PositionedReadable |
Stream that permits positional reading.
|
| RemoteIterator<E> |
An iterator over a collection whose elements need to be fetched remotely
|
| Seekable |
Stream that permits seeking.
|
| StorageStatistics.CommonStatisticNames |
These are common statistic names.
|
| Syncable |
This interface for flush/sync operation.
|
| Class | Description |
|---|---|
| AbstractFileSystem |
This class provides an interface for implementors of a Hadoop file system
(analogous to the VFS of Unix).
|
| AvroFSInput |
Adapts an
FSDataInputStream to Avro's SeekableInput interface. |
| BatchedRemoteIterator<K,E> |
A RemoteIterator that fetches elements in batches.
|
| BatchedRemoteIterator.BatchedListEntries<E> | |
| BlockLocation |
Represents the network location of a block, information about the hosts
that contain block replicas, and other block metadata (E.g.
|
| ChecksumFileSystem |
Abstract Checksumed FileSystem.
|
| CommonConfigurationKeysPublic |
This class contains constants for configuration keys used
in the common code.
|
| ContentSummary |
Store the summary of a content (a directory or a file).
|
| ContentSummary.Builder |
We don't use generics.
|
| DelegationTokenRenewer.RenewAction<T extends FileSystem & DelegationTokenRenewer.Renewable> |
An action that will renew and replace the file system's delegation
tokens automatically.
|
| DUHelper | |
| FileChecksum |
An abstract class representing file checksums for files.
|
| FileContext |
The FileContext class provides an interface to the application writer for
using the Hadoop file system.
|
| FileStatus |
Interface that represents the client side information for a file.
|
| FileSystem |
An abstract base class for a fairly generic filesystem.
|
| FileSystem.Statistics |
Tracks statistics about how many reads, writes, and so forth have been
done in a FileSystem.
|
| FileSystem.Statistics.StatisticsData |
Statistics data.
|
| FileUtil |
A collection of file-processing util methods
|
| FileUtil.HardLink | Deprecated
Use
HardLink |
| FilterFileSystem |
A
FilterFileSystem contains
some other file system, which it uses as
its basic file system, possibly transforming
the data along the way or providing additional
functionality. |
| FSDataInputStream |
Utility that wraps a
FSInputStream in a DataInputStream
and buffers input through a BufferedInputStream . |
| FSDataOutputStream |
Utility that wraps a
OutputStream in a DataOutputStream . |
| FSExceptionMessages |
Standard strings to use in exception messages in filesystems
HDFS is used as the reference source of the strings
|
| FSInputStream |
FSInputStream is a generic old InputStream with a little bit
of RAF-style seek ability.
|
| FsServerDefaults |
Provides server default configuration values to clients.
|
| FsShellPermissions.Chgrp |
Used to change group of files
|
| FsShellPermissions.Chmod |
The pattern is almost as flexible as mode allowed by chmod shell command.
|
| FsShellPermissions.Chown |
Used to change owner and/or group of files
|
| FsStatus |
This class is used to represent the capacity, free and used space on a
FileSystem . |
| GetSpaceUsed.Builder |
The builder class
|
| GlobFilter |
A filter for POSIX glob pattern with brace expansions.
|
| HardLink |
Class for creating hardlinks.
|
| HardLink.LinkStats |
HardLink statistics counters and methods.
|
| HarFileSystem |
This is an implementation of the Hadoop Archive
Filesystem.
|
| HarFs | |
| LocalFileSystem |
Implement the FileSystem API for the checksumed local filesystem.
|
| LocatedFileStatus |
This class defines a FileStatus that includes a file's block locations.
|
| MD5MD5CRC32CastagnoliFileChecksum |
For CRC32 with the Castagnoli polynomial
|
| MD5MD5CRC32GzipFileChecksum |
For CRC32 with the Gzip polynomial
|
| Options |
This class contains options related to file system operations.
|
| Options.ChecksumOpt |
This is used in FileSystem and FileContext to specify checksum options.
|
| Options.CreateOpts |
Class to support the varargs for create() options.
|
| Options.CreateOpts.BlockSize | |
| Options.CreateOpts.BufferSize | |
| Options.CreateOpts.BytesPerChecksum |
This is not needed if ChecksumParam is specified.
|
| Options.CreateOpts.ChecksumParam | |
| Options.CreateOpts.CreateParent | |
| Options.CreateOpts.Perms | |
| Options.CreateOpts.Progress | |
| Options.CreateOpts.ReplicationFactor | |
| Path |
Names a file or directory in a
FileSystem . |
| QuotaUsage |
Store the quota usage of a directory.
|
| QuotaUsage.Builder |
Builder class for QuotaUsage.
|
| RawLocalFileSystem |
Implement the FileSystem API for the raw local filesystem.
|
| StorageStatistics |
StorageStatistics contains statistics data for a FileSystem or FileContext
instance.
|
| StorageStatistics.LongStatistic |
A 64-bit storage statistic.
|
| Trash |
Provides a trash facility which supports pluggable Trash policies.
|
| TrashPolicy |
This interface is used for implementing different Trash policies.
|
| Enum | Description |
|---|---|
| CreateFlag |
CreateFlag specifies the file create semantic.
|
| GlobalStorageStatistics |
Stores global storage statistics objects.
|
| Options.Rename |
Enum to support the varargs for rename() options
|
| ReadOption |
Options that can be used when reading from a FileSystem.
|
| StorageType |
Defines the types of supported storage media.
|
| XAttrCodec |
The value of
XAttr is byte[], this class is to
covert byte[] to some kind of string representation or convert back. |
| XAttrSetFlag |
| Exception | Description |
|---|---|
| ChecksumException |
Thrown for checksum errors.
|
| FileAlreadyExistsException |
Used when target file already exists for any operation and
is not configured to be overwritten.
|
| InvalidPathException |
Path string is invalid either because it has invalid characters or due to
other file system specific reasons.
|
| InvalidRequestException |
Thrown when the user makes a malformed request, for example missing required
parameters or parameters that are not valid.
|
| ParentNotDirectoryException |
Indicates that the parent of specified Path is not a directory
as expected.
|
| PathAccessDeniedException |
EACCES
|
| PathExistsException |
Exception corresponding to File Exists - EEXISTS
|
| PathIOException |
Exceptions based on standard posix/linux style exceptions for path related
errors.
|
| PathIsDirectoryException |
EISDIR
|
| PathIsNotDirectoryException |
ENOTDIR
|
| PathIsNotEmptyDirectoryException |
Generated by rm commands
|
| PathNotFoundException |
Exception corresponding to path not found: ENOENT/ENOFILE
|
| PathOperationException |
ENOTSUP
|
| PathPermissionException |
Exception corresponding to Operation Not Permitted - EPERM
|
| UnsupportedFileSystemException |
File system for a given file system name/scheme is not supported
|
| ZeroCopyUnavailableException |
| Error | Description |
|---|---|
| FSError |
Thrown for unexpected filesystem errors, presumed to reflect disk errors
in the native filesystem.
|
Copyright © 2018 Apache Software Foundation. All Rights Reserved.


{% extends "emails/base_email.html" %}
{% block content %}
Thank you for requesting email notifications of the {{ cs_display }} address {{ b58_address }}.
Please click this link to confirm your email address:
{{ BASE_URL }}{% url 'confirm_subscription' verif_code %}
{% endblock content %}
{% block ps %}
P.S. You were sent this email because you recently requested email notifications from us.
If you didn't make this request, just ignore this email and you won't hear from us again.
Sorry for the inconvenience!
{% endblock ps %}


  From player injuries to bad trades to losses, misery will be rated on a scale from Amazin’ to END THE SEASON NOW!
The Misery Index is updated each weekday morning. Follow along as we track the Mets misery.
Mets misery score ⇛
5
Mets injury tracker
| Player | Position | Injury | DL stint | DL start |
|---|
POLL: Rate your fan misery
You rated your Mets fan misery:
Today’s average Mets-fan misery score:
Recent misery
Mets misery, day by day
Mets team misery
Mets fan misery
METS NEWS: Nothing is going right for Mets, who are worn down from all the losing
MORE: Mets trivia quiz, Mets managers quiz, Yankees sluggers tracker


Parameters that are used in the Browser.LoadData(long, LoadDataParams) method.
More...
|
| string | Data [get] |
| | Gets a string that represents data to load. More...
|
| |
| string | MimeType [get] |
| | Gets the media type of the data. E.g. "text/html", "image/jpeg" etc. More...
|
| |
| string | TextEncoding [get] |
| | Gets the text encoding of the data to load. E.g. "UTF-8", "ISO-8859-1" etc. More...
|
| |
| string | BaseURL [get] |
| | Gets origin URL of the document that will be used to resolve links with relative path in HTML document. This parameter is used only for HTML data with "text/html" mime type. More...
|
| |
Parameters that are used in the Browser.LoadData(long, LoadDataParams) method.
| DotNetBrowser.LoadDataParams.LoadDataParams |
( |
string |
data, |
|
|
string |
mimeType, |
|
|
string |
textEncoding, |
|
|
string |
baseURL |
|
) |
| |
Constructs a new LoadDataParams instance.
- Parameters
-
| data | a string that represent data to load. |
| mimeType | media type of the data. E.g. "text/html", "image/jpeg" etc. |
| textEncoding | encoding of the data. E.g. "UTF-8". |
| baseURL | indicates the origin URL of the document and it's used to resolve links. This parameter is used only for HTML data with "text/html" mime type. |
| override string DotNetBrowser.LoadDataParams.ToString |
( |
| ) |
|
Represent object as string
- Returns
- a string that represents the object
| string DotNetBrowser.LoadDataParams.BaseURL |
|
get |
Gets origin URL of the document that will be used to resolve links with relative path in HTML document. This parameter is used only for HTML data with "text/html" mime type.
the origin URL of the document.
| string DotNetBrowser.LoadDataParams.Data |
|
get |
Gets a string that represents data to load.
a string that represents data to load.
| string DotNetBrowser.LoadDataParams.MimeType |
|
get |
Gets the media type of the data. E.g. "text/html", "image/jpeg" etc.
the media type of the data.
| string DotNetBrowser.LoadDataParams.TextEncoding |
|
get |
Gets the text encoding of the data to load. E.g. "UTF-8", "ISO-8859-1" etc.
the text encoding of the data to load.


NLTK
NLTK is a leading platform for building Python programs to work with human language data. It provides easy-to-use interfaces to over 50 corpora and lexical resources such as WordNet, along with a suite of text processing libraries for classification, tokenization, stemming, tagging, parsing, and semantic reasoning, and an active discussion forum.
Library documentation: http://www.nltk.org/
# needed to display the graphs
%matplotlib inline
# import the library and download sample texts
import nltk
nltk.download('gutenberg')
nltk.download('genesis')
nltk.download('inaugural')
nltk.download('nps_chat')
nltk.download('webtext')
nltk.download('treebank')
nltk.download('stopwords')
nltk.download('words')
nltk.download('wordnet')
nltk.download('brown')
nltk.download('names')
nltk.download('movie_reviews')
nltk.download('punkt')
nltk.download('averaged_perceptron_tagger')
nltk.download('universal_tagset')
from nltk.book import *
# examine concordances (word + context)
text1.concordance("monstrous")
text1.similar("monstrous")
text2.common_contexts(["monstrous", "very"])
# see where in a text certain words are found to occur
text4.dispersion_plot(["citizens", "democracy", "freedom", "duties", "America"])
# count of all tokens (including punctuation)
len(text3)
# number of distinct tokens
len(set(text3))
# the texts are just lists of strings
text2[141525:]
# build a frequency distribution
fdist1 = FreqDist(text1)
fdist1
fdist1.most_common(20)
fdist1['whale']
fdist1.plot(20, cumulative=True)
# apply a list comprehension to get words over 15 characters
V = set(text1)
long_words = [w for w in V if len(w) > 15]
sorted(long_words)
fdist2 = FreqDist(text5)
sorted(w for w in set(text5) if len(w) > 7 and fdist2[w] > 7)
# word sequences that appear together unusually often
text4.collocations()
Raw Text Processing
# download raw text from an online repository
from urllib import request
url = "http://www.gutenberg.org/files/2554/2554-0.txt"
response = request.urlopen(url)
raw = response.read().decode('utf8')
len(raw)
raw[:75]
# tokenize the raw text
from nltk import word_tokenize
tokens = word_tokenize(raw)
len(tokens)
tokens[:10]
text = nltk.Text(tokens)
text[1024:1062]
text.collocations()
raw.find("PART I")
# HTML parsing using the Beautiful Soup library
from bs4 import BeautifulSoup
url = "http://news.bbc.co.uk/2/hi/health/2284783.stm"
html = request.urlopen(url).read().decode('utf8')
raw = BeautifulSoup(html, 'html.parser').get_text()
tokens = word_tokenize(raw)
tokens[0:10]
# isolate just the article text
tokens = tokens[110:390]
text = nltk.Text(tokens)
text.concordance('gene')
Regular Expressions
# regular expression library
import re
wordlist = [w for w in nltk.corpus.words.words('en') if w.islower()]
# match the end of a word
[w for w in wordlist if re.search('ed$', w)][0:10]
# wildcard matches any single character
[w for w in wordlist if re.search('^..j..t..$', w)][0:10]
# combination of caret (start of word) and sets
[w for w in wordlist if re.search('^[ghi][mno][jlk][def]$', w)]
chat_words = sorted(set(w for w in nltk.corpus.nps_chat.words()))
# plus symbol matches any number of times repeating
[w for w in chat_words if re.search('^m+i+n+e+$', w)]
wsj = sorted(set(nltk.corpus.treebank.words()))
# more advanced regex example
[w for w in wsj if re.search('^[0-9]+\.[0-9]+$', w)][0:10]
[w for w in wsj if re.search('^[A-Z]+\$$', w)]
[w for w in wsj if re.search('^[0-9]{4}$', w)][0:10]
[w for w in wsj if re.search('^[0-9]+-[a-z]{3,5}$', w)][0:10]
[w for w in wsj if re.search('^[a-z]{5,}-[a-z]{2,3}-[a-z]{,6}$', w)][0:10]
[w for w in wsj if re.search('(ed|ing)$', w)][0:10]
# using "findall" to extract partial matches from words
fd = nltk.FreqDist(vs for word in wsj
for vs in re.findall(r'[aeiou]{2,}', word))
fd.most_common(12)
Normalizing Text
# NLTK has several word stemmers built in
porter = nltk.PorterStemmer()
lancaster = nltk.LancasterStemmer()
[porter.stem(t) for t in tokens][0:10]
[lancaster.stem(t) for t in tokens][0:10]
wnl = nltk.WordNetLemmatizer()
[wnl.lemmatize(t) for t in tokens][0:10]
# also has a tokenizer that takes a regular expression as a parameter
text = 'That U.S.A. poster-print costs $12.40...'
pattern = r'''(?x) # set flag to allow verbose regexps
([A-Z]\.)+ # abbreviations, e.g. U.S.A.
| \w+(-\w+)* # words with optional internal hyphens
| \$?\d+(\.\d+)?%? # currency and percentages, e.g. $12.40, 82%
| \.\.\. # ellipsis
| [][.,;"'?():-_`] # these are separate tokens; includes ], [
'''
nltk.regexp_tokenize(text, pattern)
Tagging
# Use a built-in tokenizer and tagger
text = word_tokenize("They refuse to permit us to obtain the refuse permit")
nltk.pos_tag(text)
# Word similarity using a pre-tagged text
text = nltk.Text(word.lower() for word in nltk.corpus.brown.words())
text.similar('woman')
# Tagged words are saved as tuples
nltk.corpus.brown.tagged_words()[0:10]
nltk.corpus.brown.tagged_words(tagset='universal')[0:10]
from nltk.corpus import brown
brown_news_tagged = brown.tagged_words(categories='news', tagset='universal')
tag_fd = nltk.FreqDist(tag for (word, tag) in brown_news_tagged)
tag_fd.most_common()
# Part of speech tag count for words following "often" in a text
brown_lrnd_tagged = brown.tagged_words(categories='learned', tagset='universal')
tags = [b[1] for (a, b) in nltk.bigrams(brown_lrnd_tagged) if a[0] == 'often']
fd = nltk.FreqDist(tags)
fd.tabulate()
# Load some raw sentences to tag
from nltk.corpus import brown
brown_tagged_sents = brown.tagged_sents(categories='news')
brown_sents = brown.sents(categories='news')
# Default tagger (assigns same tag to each token)
tags = [tag for (word, tag) in brown.tagged_words(categories='news')]
nltk.FreqDist(tags).max()
raw = 'I do not like green eggs and ham, I do not like them Sam I am!'
tokens = word_tokenize(raw)
default_tagger = nltk.DefaultTagger('NN')
default_tagger.tag(tokens)
# Evaluate the performance against a tagged corpus
default_tagger.evaluate(brown_tagged_sents)
# Training a unigram tagger
from nltk.corpus import brown
brown_tagged_sents = brown.tagged_sents(categories='news')
brown_sents = brown.sents(categories='news')
unigram_tagger = nltk.UnigramTagger(brown_tagged_sents)
unigram_tagger.tag(brown_sents[2007])
# Now evaluate it
unigram_tagger.evaluate(brown_tagged_sents)
# Combining taggers
t0 = nltk.DefaultTagger('NN')
t1 = nltk.UnigramTagger(brown_tagged_sents, backoff=t0)
t2 = nltk.BigramTagger(brown_tagged_sents, backoff=t1)
t2.evaluate(brown_tagged_sents)
Classifying Text
# Define a feature extractor
def gender_features(word):
return {'last_letter': word[-1]}
gender_features('Shrek')
# Prepare a list of examples
from nltk.corpus import names
labeled_names = ([(name, 'male') for name in names.words('male.txt')] +
[(name, 'female') for name in names.words('female.txt')])
import random
random.shuffle(labeled_names)
# Process the names data
featuresets = [(gender_features(n), gender) for (n, gender) in labeled_names]
train_set, test_set = featuresets[500:], featuresets[:500]
classifier = nltk.NaiveBayesClassifier.train(train_set)
classifier.classify(gender_features('Neo'))
classifier.classify(gender_features('Trinity'))
print(nltk.classify.accuracy(classifier, test_set))
classifier.show_most_informative_features(5)
# Document classification
from nltk.corpus import movie_reviews
documents = [(list(movie_reviews.words(fileid)), category)
for category in movie_reviews.categories()
for fileid in movie_reviews.fileids(category)]
random.shuffle(documents)
all_words = nltk.FreqDist(w.lower() for w in movie_reviews.words())
word_features = list(all_words)[:2000]
def document_features(document):
document_words = set(document)
features = {}
for word in word_features:
features['contains({})'.format(word)] = (word in document_words)
return features
featuresets = [(document_features(d), c) for (d,c) in documents]
train_set, test_set = featuresets[100:], featuresets[:100]
classifier = nltk.NaiveBayesClassifier.train(train_set)
print(nltk.classify.accuracy(classifier, test_set))
classifier.show_most_informative_features(5)


The utterance of God is a lamp, whose light is these words: Ye are the fruits of one tree, and the leaves of one branch. Deal ye one with another with the utmost love and harmony, with friendliness and fellowship.
The Bahá'í Community of Irving invites you to celebrate the
Bicentenary of the
Birth of Bahá'u'lláh
Sunday October 22, 2017
4:30 - 8:00 pm
Doors open at 4:00 pm
Please be seated by 4:30 pm for the program
Program & Dinner
Dallas/Fort Worth Airport Marriott
8440 Freeport Pkwy, Irving, TX 75063
Semiformal attire
Buffet dinner with vegetarian and vegan options
Please Register / RVSP
by October 6


///<reference path="../../_definitions.ts"/>
/**
* A class that provides constant values for visual blend mode effects. These
* constants are used in the following:
*

*
 The blendMode property of the
* flash.display.DisplayObject class.

*
 The blendMode parameter of the draw()
* method of the flash.display.BitmapData class

*

*/
module away.base
{
export class BlendMode
{
/**
* Adds the values of the constituent colors of the display object to the
* colors of its background, applying a ceiling of 0xFF. This setting is
* commonly used for animating a lightening dissolve between two objects.
*
*
For example, if the display object has a pixel with an RGB value of
* 0xAAA633, and the background pixel has an RGB value of 0xDD2200, the
* resulting RGB value for the displayed pixel is 0xFFC833(because 0xAA +
* 0xDD > 0xFF, 0xA6 + 0x22 = 0xC8, and 0x33 + 0x00 = 0x33).

*/
public static ADD:string = "add";
/**
* Applies the alpha value of each pixel of the display object to the
* background. This requires the blendMode property of the
* parent display object be set to
* away.base.BlendMode.LAYER.
*
*
Not supported under GPU rendering.

*/
public static ALPHA:string = "alpha";
/**
* Selects the darker of the constituent colors of the display object and the
* colors of the background(the colors with the smaller values). This
* setting is commonly used for superimposing type.
*
*
For example, if the display object has a pixel with an RGB value of
* 0xFFCC33, and the background pixel has an RGB value of 0xDDF800, the
* resulting RGB value for the displayed pixel is 0xDDCC00(because 0xFF >
* 0xDD, 0xCC < 0xF8, and 0x33 > 0x00 = 33).

*
*
Not supported under GPU rendering.

*/
public static DARKEN:string = "darken";
/**
* Compares the constituent colors of the display object with the colors of
* its background, and subtracts the darker of the values of the two
* constituent colors from the lighter value. This setting is commonly used
* for more vibrant colors.
*
*
For example, if the display object has a pixel with an RGB value of
* 0xFFCC33, and the background pixel has an RGB value of 0xDDF800, the
* resulting RGB value for the displayed pixel is 0x222C33(because 0xFF -
* 0xDD = 0x22, 0xF8 - 0xCC = 0x2C, and 0x33 - 0x00 = 0x33).

*/
public static DIFFERENCE:string = "difference";
/**
* Erases the background based on the alpha value of the display object. This
* process requires that the blendMode property of the parent
* display object be set to flash.display.BlendMode.LAYER.
*
*
Not supported under GPU rendering.

*/
public static ERASE:string = "erase";
/**
* Adjusts the color of each pixel based on the darkness of the display
* object. If the display object is lighter than 50% gray, the display object
* and background colors are screened, which results in a lighter color. If
* the display object is darker than 50% gray, the colors are multiplied,
* which results in a darker color. This setting is commonly used for shading
* effects.
*
*
Not supported under GPU rendering.

*/
public static HARDLIGHT:string = "hardlight";
/**
* Inverts the background.
*/
public static INVERT:string = "invert";
/**
* Forces the creation of a transparency group for the display object. This
* means that the display object is precomposed in a temporary buffer before
* it is processed further. The precomposition is done automatically if the
* display object is precached by means of bitmap caching or if the display
* object is a display object container that has at least one child object
* with a blendMode setting other than "normal".
*
*
Not supported under GPU rendering.

*/
public static LAYER:string = "layer";
/**
* Selects the lighter of the constituent colors of the display object and
* the colors of the background(the colors with the larger values). This
* setting is commonly used for superimposing type.
*
*
For example, if the display object has a pixel with an RGB value of
* 0xFFCC33, and the background pixel has an RGB value of 0xDDF800, the
* resulting RGB value for the displayed pixel is 0xFFF833(because 0xFF >
* 0xDD, 0xCC < 0xF8, and 0x33 > 0x00 = 33).

*
*
Not supported under GPU rendering.

*/
public static LIGHTEN:string = "lighten";
/**
* Multiplies the values of the display object constituent colors by the
* constituent colors of the background color, and normalizes by dividing by
* 0xFF, resulting in darker colors. This setting is commonly used for
* shadows and depth effects.
*
*
For example, if a constituent color(such as red) of one pixel in the
* display object and the corresponding color of the pixel in the background
* both have the value 0x88, the multiplied result is 0x4840. Dividing by
* 0xFF yields a value of 0x48 for that constituent color, which is a darker
* shade than the color of the display object or the color of the
* background.

*/
public static MULTIPLY:string = "multiply";
/**
* The display object appears in front of the background. Pixel values of the
* display object override the pixel values of the background. Where the
* display object is transparent, the background is visible.
*/
public static NORMAL:string = "normal";
/**
* Adjusts the color of each pixel based on the darkness of the background.
* If the background is lighter than 50% gray, the display object and
* background colors are screened, which results in a lighter color. If the
* background is darker than 50% gray, the colors are multiplied, which
* results in a darker color. This setting is commonly used for shading
* effects.
*
*
Not supported under GPU rendering.

*/
public static OVERLAY:string = "overlay";
/**
* Multiplies the complement(inverse) of the display object color by the
* complement of the background color, resulting in a bleaching effect. This
* setting is commonly used for highlights or to remove black areas of the
* display object.
*/
public static SCREEN:string = "screen";
/**
* Uses a shader to define the blend between objects.
*
*
Setting the blendShader property to a Shader instance
* automatically sets the display object's blendMode property to
* BlendMode.SHADER. If the blendMode property is
* set to BlendMode.SHADER without first setting the
* blendShader property, the blendMode property is
* set to BlendMode.NORMAL instead. If the
* blendShader property is set(which sets the
* blendMode property to BlendMode.SHADER), then
* later the value of the blendMode property is changed, the
* blend mode can be reset to use the blend shader simply by setting the
* blendMode property to BlendMode.SHADER. The
* blendShader property does not need to be set again except to
* change the shader that's used to define the blend mode.

*
*
Not supported under GPU rendering.

*/
public static SHADER:string = "shader";
/**
* Subtracts the values of the constituent colors in the display object from
* the values of the background color, applying a floor of 0. This setting is
* commonly used for animating a darkening dissolve between two objects.
*
*
For example, if the display object has a pixel with an RGB value of
* 0xAA2233, and the background pixel has an RGB value of 0xDDA600, the
* resulting RGB value for the displayed pixel is 0x338400(because 0xDD -
* 0xAA = 0x33, 0xA6 - 0x22 = 0x84, and 0x00 - 0x33 < 0x00).

*/
public static SUBTRACT:string = "subtract";
}
}


earangodb (eArangoDB v0.1)
Link to this section Summary
Functions
The same as
collection_create(Name, document)
functionCreates a new collection with a given name and type.
Drops the collection identified by collection-name.
Returns an object with an attribute result containing an array of all collection descriptions.
Creates a new document from the document given in the body, unless there is already a document with the _key given.
Deletes the specified document with a given key.
Returns the document identified by document-id. The returned document contains three special attribute _key containing key which uniquely identifies a document in a given collection.
Replaces the specified document with the one in the body, provided there is such a document .
Partially updates the document identified by document-id. The body of the request must contain a JSON document with the attributes to patch (the patch document). All attributes from the patch document will be added to the existing document if they do not yet exist, and overwritten in the existing document if they do exist there.
Allows to execute AQL queries.
Creates a new edge in the collection.
Removes an edge from the collection.
Gets an edge from the given collection.
Updates an edge from the given collection.
Adds a vertex to the given collection.
Removes a vertex from the collection.
Gets a vertex from the collection with a given key.
Replaces the data of the specific vertex in the collection.
Updates the data of the specific vertex in the collection.
The creation of a graph requires the name of the graph and a definition of its edges.
Drops an existing graph object by name.
Selects information for a given graph. Will return the edge definitions as well as the orphan collections. Or returns a 404 if the graph does not exist.
Lists all graphs stored in this database.
Link to this section Types
Link to this type
ok_response_or_error_reason/0
Specs
ok_response_or_error_reason() :: {ok, map()} | {error, Reason :: term()}.
Link to this section Functions
Link to this function
collection_create(Name)
Specs
collection_create(Name :: binary()) -> ok_response_or_error_reason().
collection_create(Name, document)
function
Link to this function
collection_create(Name, CollectionType)
Specs
collection_create(Name :: binary(), CollectionType :: earangodb_collections:collection_type()) -> ok_response_or_error_reason().
Link to this function
collection_delete(Name)
Specs
collection_delete(Name :: binary()) -> ok_response_or_error_reason().
Link to this function
collections_list()
Specs
collections_list() -> [earangodb_collections:collection_info()].
Link to this function
document_create(CollectionName, Document)
Specs
document_create(CollectionName :: binary(), Document :: map()) -> ok_response_or_error_reason().
Link to this function
document_delete(CollectionName, DocumentKey)
Specs
document_delete(CollectionName :: binary(), DocumentKey :: binary()) -> ok_response_or_error_reason().
Link to this function
document_read(CollectionName, DocumentKey)
Specs
document_read(CollectionName :: binary(), DocumentKey :: binary()) -> ok_response_or_error_reason().
Link to this function
document_replace(CollectionName, DocumentKey, Document)
Specs
document_replace(CollectionName :: binary(), DocumentKey :: binary(), Document :: map()) -> ok_response_or_error_reason().
Link to this function
document_update(CollectionName, DocumentKey, Document)
Specs
document_update(CollectionName :: binary(), DocumentKey :: binary(), Document :: map()) -> ok_response_or_error_reason().
Link to this function
execute_query(Query, Count, BatchSize)
Specs
execute_query(Query :: binary(), Count :: boolean(), BatchSize :: pos_integer()) -> {ok, Result :: [map()]} | {error, Reason :: term()}.
Link to this function
graph_edge_create(GraphName, EdgesCollectionName, FromVertex, ToVertex, Properties)
Specs
graph_edge_create(GraphName :: binary(), EdgesCollectionName :: binary(), FromVertex :: integer(), ToVertex :: integer(), Properties :: map()) -> ok_response_or_error_reason().
Link to this function
graph_edge_delete(GraphName, CollectionName, EdgeKey)
Specs
graph_edge_delete(GraphName :: binary(), CollectionName :: binary(), EdgeKey :: binary()) -> ok_response_or_error_reason().
Link to this function
graph_edge_get(GraphName, CollectionName, EdgeKey)
Specs
graph_edge_get(GraphName :: binary(), CollectionName :: binary(), EdgeKey :: binary()) -> ok_response_or_error_reason().
Link to this function
graph_edge_update(GraphName, CollectionName, EdgeKey, UpdateDoc)
Specs
graph_edge_update(GraphName :: binary(), CollectionName :: binary(), EdgeKey :: binary(), UpdateDoc :: map()) -> ok_response_or_error_reason().
Link to this function
graph_vertex_create(GraphName, CollectionName, VertexDocument)
Specs
graph_vertex_create(GraphName :: binary(), CollectionName :: binary(), VertexDocument :: map()) -> ok_response_or_error_reason().
Link to this function
graph_vertex_delete(GraphName, CollectionName, VertexKey)
Specs
graph_vertex_delete(GraphName :: binary(), CollectionName :: binary(), VertexKey :: binary()) -> ok_response_or_error_reason().
Link to this function
graph_vertex_get(GraphName, CollectionName, VertexKey)
Specs
graph_vertex_get(GraphName :: binary(), CollectionName :: binary(), VertexKey :: binary()) -> ok_response_or_error_reason().
Link to this function
graph_vertex_replace(GraphName, CollectionName, VertexKey, ReplaceDoc)
Specs
graph_vertex_replace(GraphName :: binary(), CollectionName :: binary(), VertexKey :: binary(), ReplaceDoc :: map()) -> ok_response_or_error_reason().
Link to this function
graph_vertex_update(GraphName, CollectionName, VertexKey, UpdateDoc)
Specs
graph_vertex_update(GraphName :: binary(), CollectionName :: binary(), VertexKey :: binary(), UpdateDoc :: map()) -> ok_response_or_error_reason().
Link to this function
graphs_create(GraphName, EdgesCollection, FromCollections, ToCollections)
Specs
graphs_create(GraphName :: binary(), EdgesCollection :: binary(), FromCollections :: [binary()], ToCollections :: [binary()]) -> ok_response_or_error_reason().
Link to this function
graphs_delete(GraphName)
Specs
graphs_delete(GraphName :: binary()) -> ok_response_or_error_reason().
Link to this function
graphs_get(GraphName)
Specs
graphs_get(GraphName :: binary()) -> ok_response_or_error_reason().
Link to this function
graphs_list()
Specs
graphs_list() -> ok_response_or_error_reason().


This is the well-known 15-puzzle, designed by Samuel Loyd. Most tiles are already in the right place. Click on tiles to move them and finish the job.
Built with Constrain


Provides flexible Bayesian estimation of Infinite Mixtures of Infinite Factor Analysers and related models, for nonparametrically clustering high-dimensional data, introduced by Murphy et al. (2017) <arXiv:1701.07010v4>. The IMIFA model conducts Bayesian nonparametric model-based clustering with factor analytic covariance structures without recourse to model selection criteria to choose the number of clusters or cluster-specific latent factors, mostly via efficient Gibbs updates. Model-specific diagnostic tools are also provided, as well as many options for plotting results, conducting posterior inference on parameters of interest, and quantifying uncertainty.
| Version: | 2.0.0 |
| Depends: | R (≥ 3.3.0) |
| Imports: | matrixStats, mclust (≥ 5.1), mvnfast, Rfast (≥ 1.8.4), slam, viridis |
| Suggests: | gmp, knitr, mcclust, methods, rmarkdown, Rmpfr |
| Published: | 2018-05-01 |
| Author: | Keefe Murphy [aut, cre], Isobel Claire Gormley [ctb], Cinzia Viroli [ctb] |
| Maintainer: | Keefe Murphy <keefe.murphy at ucd.ie> |
| BugReports: | https://github.com/Keefe-Murphy/IMIFA |
| License: | GPL-2 | GPL-3 [expanded from: GPL (≥ 2)] |
| URL: | https://cran.r-project.org/package=IMIFA |
| NeedsCompilation: | no |
| Citation: | IMIFA citation info |
| Materials: | README NEWS |
| In views: | Cluster |
| CRAN checks: | IMIFA results |
| Reference manual: | IMIFA.pdf |
| Vignettes: |
Infinite Mixtures of Infinite Factor Analysers |
| Package source: | IMIFA_2.0.0.tar.gz |
| Windows binaries: | r-devel: IMIFA_2.0.0.zip, r-release: IMIFA_2.0.0.zip, r-oldrel: IMIFA_2.0.0.zip |
| OS X binaries: | r-release: IMIFA_2.0.0.tgz, r-oldrel: IMIFA_2.0.0.tgz |
| Old sources: | IMIFA archive |
Please use the canonical form https://CRAN.R-project.org/package=IMIFA to link to this page.


Umbrella sampling for cosmology
This project uses umbrella sampling (US) on a cosmology model to sample extremely low-probability areas of the posterior distribution that may be required in statistical analyses of data. The technique is tested on deriving cosmological constraints using the supernova type Ia data. We show that US can sample the posterior \(\pi(x)\) accurately down to the \(\approx15\sigma\) credible region in the \(\Omega_m-\Omega_\Lambda\) plane, while for the same computational effort the affine-invariant MCMC sampling implemented in the popular emcee code samples the posterior reliably only to \(\approx3\sigma\).
In the US algorithm, sampling of the posterior is split (or stratified) into several easier sampling problems (see the Figure below). Specifically, a sequence of overlapping window functions, or umbrellas \(\psi_i(x)\), is introduced and the algorithm samples the corresponding distributions, \(\pi_i(x)\propto \psi_i(\theta)\pi(x)\). Selecting windows in low-probability regions of the posterior and thereby confining samples of \(\pi_i\) to these regions, allows one to get a much more efficient coverage of outlying areas of the posterior and ensure discovery of widely separated peaks in multimodal distributions. In this sense, the US approach is a part of a large class of MCMC methods that are designed to sample the parameter space more uniformly, such as parallel tempering and parallel MCMC.
Clearly, the approach is most effective when we have some knowledge about the low-probability regions of the target distribution, as umbrellas can be designed specifically to sample these regions efficiently. Such information is often available either from prior intuition about the overall problem or from exploratory MCMC runs. We may use a collective variable (CV) to bias the simulation in a specific direction.
However US can be efficiently applied even in cases when no such prior information is available. In this case umbrella windows can be chosen so that the \(\pi_i\) correspond to tempered distributions, defined as in the Parallel Tempering method. US provides a mechanism by which samples from the high-temperature distributions (in low-probability regions) can be incorporated into more accurate estimates of tail probabilities.
To illustrate the power of the US algorithm to accurately sample the tails of the marginal posterior distribution, we use cosmological constraints derived from type Ia supernovae observations. Specifically, we sample the marginal posterior of the mean dimensionless matter and vacuum energy densities, \(\Omega_m\) \(\Omega_\Lambda\), using the SDSS-II/SNLS3 Joint Light-curve Analysis (JLA) supernovae data set and the associated JLA v3 likelihood.
Type Ia supernovae are one of the key probes of the cosmological parameters governing expansion of the Universe and played the main role in the discovery of the accelerating expansion of the Universe. The current supernovae samples, such as the JLA data set, cover a wide range of redshifts and provide complimentary constraints to those derived from the Cosmic Microwave Background and the Baryonic Acoustic Oscillations measurements.
We test two different parameterizations of windows in the US approach: temperature stratification only and a combination of the temperature stratification with a CV. The latter is possible in this case because we are interested in estimating the probability that the Universe is not accelerating, and we can define the CV in the direction perpendicular to the line separating accelerating and non-accelerating universes: \(\Omega_m/2−\Omega_\Lambda=0\).
The Figure shows results of sampling the JLA v3 likelihood in six-dimensional parameter space using the Goodman & Weare algorithm implemented in the emcee package, and US with different choices of the umbrella partition. Here, we sample the JLA v3 likelihood using the COSMOSIS package to which we have added the US sampler. In each case, the sampling was done using the same number of likelihood evaluations and same computer wall time.
The runs using emcee used all 32 available cores in parallel. The US runs used 16 windows sampled in parallel, each with two cores that also worked in parallel. This gave the US results the same parallel efficiency as the emcee sampler. An MPI pool object was used to na"ively distribute the tasks evenly, without any load balancing.
The results obtained using US with only temperature show a higher variance than results using CVs, as is evident from the spikier and less-defined contours at the furthest sigma levels. This is simply because umbrella windows with the CV stratified, ensure that a fixed number of walkers sample the low-probability areas of the posterior in the plane, while in the temperature windows walkers explore the entirety of the parameter space without any restraints.
The faint dotted lines correspond to the contours assuming a Gaussian approximation of the posterior. The sampled log-likelihood surface was fit to a quadratic form using the Matlab fit function, and its corresponding sigma levels plotted. Although the initial agreement up to the third contour is good, it is clear that the Gaussian approximation fails to accurately describe the tails of the posterior. The sampled surface obtained from US shows that there exists a much ‘fatter’ tail compared to the Gaussian.


Following Baron Schwartz' post: How to calculate a good InnoDB log file size, which shows how to make an estimate for the InnoDB log file size, and based on SQL: querying for status difference over time, I've written a query to run on MySQL 5.1, which, upon sampling 60 seconds of status, estimates the InnoDB transaction log bytes that are expected to be written in the period of 1 hour.
Recap: this information can be useful if you're looking for a good innodb_log_file_size value, such that will not pose too much I/O (smaller values will make for more frequent flushes), not will make for a too long recovery time (larger values mean more transactions to recover upon crash).
It is assumed that the 60 seconds period represents an average system load, not some activity spike period. Edit the sleep time and factors as you will to sample longer or shorter periods.
SELECT innodb_os_log_written_per_minute*60 AS estimated_innodb_os_log_written_per_hour, CONCAT(ROUND(innodb_os_log_written_per_minute*60/1024/1024, 1), 'MB') AS estimated_innodb_os_log_written_per_hour_mb FROM (SELECT SUM(value) AS innodb_os_log_written_per_minute FROM ( SELECT -VARIABLE_VALUE AS value FROM INFORMATION_SCHEMA.GLOBAL_STATUS WHERE VARIABLE_NAME = 'innodb_os_log_written' UNION ALL SELECT SLEEP(60) FROM DUAL UNION ALL SELECT VARIABLE_VALUE FROM INFORMATION_SCHEMA.GLOBAL_STATUS WHERE VARIABLE_NAME = 'innodb_os_log_written' ) s1 ) s2 ;
Sample output:
comments powered by Disqus+------------------------------------------+---------------------------------------------+ | estimated_innodb_os_log_written_per_hour | estimated_innodb_os_log_written_per_hour_mb | +------------------------------------------+---------------------------------------------+ | 584171520 | 557.1MB | +------------------------------------------+---------------------------------------------+


| cli_progress_demo {cli} | R Documentation |
Useful for experimenting with format strings and for documentation. It creates a progress bar, iterates it until it terminates and saves the progress updates.
cli_progress_demo( name = NULL, status = NULL, type = c("iterator", "tasks", "download", "custom"), total = NA, .envir = parent.frame(), ..., at = if (is_interactive()) NULL else 50, show_after = 0, live = NULL, delay = 0, start = as.difftime(5, units = "secs") )
name |
Passed to |
status |
Passed to |
type |
Passed to |
total |
Passed to |
.envir |
Passed to |
... |
Passed to |
at |
The number of progress units to show and capture the progress
bar at. If |
show_after |
Delay to show the progress bar. Overrides the
|
live |
Whether to show the progress bat on the screen, or just
return the recorded updates. Defaults to the value of the
|
delay |
Delay between progress bar updates. |
start |
Time to subtract from the start time, to simulate a progress bar that takes longer to run. |
List with class cli_progress_demo
, which has a print and a
format method for prretty printing. The lines
entry contains the
output lines, each correcponding to one update.


Before Change
// is launched with full_init=True. If PantsdDaemon is launched with
// full_init=True, we can guarantee self._native is non-None.
native = cast(Native, self._native)
log_handler = setup_logging(
self._log_level,
native=native,
log_dir=self._log_dir,
log_filename=self.LOG_NAME,
warnings_filter_regexes=self._bootstrap_options.for_global_scope(), // type: ignore[union-attr]
)
// We know log_handler is never None because we did pass a non-None `log_dir`
// to setup_logging.
log_handler = cast(NativeHandler, log_handler)
native.override_thread_logging_destination_to_just_pantsd()
// Do a python-level redirect of stdout/stderr, which will not disturb `0,1,2`.
// TODO: Consider giving these pipes/actual fds, in order to make them "deep" replacements
After Change
ignores = bootstrap_options.for_global_scope().ignore_pants_warnings
clear_previous_loggers()
setup_logging_to_stderr(level, warnings_filter_regexes=ignores)
log_dir = os.path.join(self._work_dir, self.name)
log_handler = setup_logging_to_file(
level, log_dir=log_dir, log_filename=self.LOG_NAME, warnings_filter_regexes=ignores
)
native.override_thread_logging_destination_to_just_pantsd()
// Do a python-level redirect of stdout/stderr, which will not disturb `0,1,2`.


Some quick example text to build on the card title and make up the bulk of the card's content.
Release Date: 12/12/2019


In the sixty-first session, the UN General Assembly proclaimed the Year 2008 the International Year of
Languages. The Organization took this step to highlight the importance of preserving multilingualism and
the diversity of cultures around the world.
Below is an excerpt from the UN document proclaiming 2008 the International Year of Languages:
To celebrate the International Year of Languages, the UN Language and Communications Programme, under the direction of Officer-in-Charge, Javier Zanon and team organized some special activities during the spring and fall of 2008:
Speaking Tables - staff chat during lunch in one of the six languages (other than their native language)
Counting Languages at the UN - counting the number of languages spoken by staff
Authors' Readings for Literacy - authors do readings form their work and put their books in the service of the cause of literacy (Click here to see photos and excerpts from readings)
Authors' Readings/Reception/International Mother Language - click here for some pre and post-reading photos
Book Fair for Literacy and the Literacy Projects it Supports - UN staff donate books
to an annual Book fair to support literacy projects
Click here to see photos of the
projects
Click here to see photos from past book
fairs
Did you know that virtually all languages -- no matter how different -- have an interesting feature
in common?
That feature is the use of metaphor. A “metaphor” is a way of explaining something abstract
in terms
of something concrete, i.e. something that is experienced through our five senses and part of our
everyday experience.
For example, all languages have metaphors that:
|
Show “time” in terms of movement through space
|
Show importance in terms of size:
|
|
Show positive emotions in terms of “brightness” or “higher temperature
|
Show difficulty or ease in terms of “hardness” or “softness”, “bitterness” or
“sweetness”
|
(Above information on “metaphor” is from a presentation by Prof Carmen Betones, University of Almeria, curso de verano 2008, Fine Art, Language, and Synesthesia)
Think about your own language. What are some typical phrases that show examples of one or more of the above metaphors?
For example, language metaphors describe time in spatial terms. Many languages have the metaphor
of a
“wheel of time”, “life as a journey along a road” or “time line” with an embellished “time landscape”).
Many people report visualizing an internal calendar or “time landscape”, a personalized image of time. A
year as one such circle is a popular image.
According to scientist Stanislas Dehaene (author of The Number Sense and research scientist at INSERM in
France), “a majority of people have an unconscious mental number line oriented from left to right…
Between 5 per cent and 10 per cent of humanity is convinced that numbers have colors and occupy very
precise locations in space”. Such personal visualizations can extend to internal time lines and even an
internal “alphabet line”.
According to the reading passage, a majority of people experience the language of numbers as an
internal “number line” or “time line” with a sense of dimension. For between 5 and 10 per cent, these
internal “lines” can be embellished with color or shapes other than lines. Some people can also
experience an internal “alphabet line”. (https://en.wikipedia.org/wiki/Number_form).
Below is a description of the “alphabet landscape” of the great twentieth century fiction writer,
Vladimir Nabokov. Nabokov visualized an internal alphabet with color and texture (that he imagined
himself moving through). The colors of the alphabet letters varied in the different languages he
knew):
“The long a of the English alphabet has for me the tint of weathered wood, but a French
a evokes
polished ebony…[there is] the fluffy-gray, three-stemmed Russian letter that stands for sh...
In the
green group, there are are alder-leaf f, the unripe apple of p and pistachio t.
Dull green, combined
somehow with violet is the best I can do for w. The yellows comprise various e’s and
i’s, creamy d,
bright golden y and u, whose alphabetical value I can express only by brassy with an
olive sheen….”
--from Speak Memory, (Vladimir Nabokov’s autobiography)
Interview someone you know. Ask if he/she visualizes a timeline, a number line, or an alphabet line.


this is me
this is me
this is me
this is me
this is me
this is me
this is me
this is me
this is me
this is me
this is me
this is me
this is me


{% extends "base.html" %} {% block content %} You have encountered an error. Please try again later. {% endblock %}


_The_Wood_ (R) *** (out of ****)
So-called "urban" films almost always tend to be consigned to a box office ghetto of their own, rarely connecting beyond its target African-American audiences, even if the film has cross-demographic appeal. Even with the promotional muscle of MTV Productions behind it, _The_Wood_ is not likely to be an exception to the rule, but this warm and funny, if somewhat uneven, film deserves to be.
The film's title refers to Inglewood, California, and if anyone outside of the Southern California area knows about the city, it's for either one of two reasons: (1) it's the home of the Great Western Forum, longtime arena to the Los Angeles Lakers (at least until this coming fall); or (2) it's known for its gang activity. The latter would be the obvious angle to pursue, but aside from the gang connections of one secondary character, writer-director Rick Famuyiwa admirably skirts the issue. Famuyiwa grew up in Inglewood, and his take on the city is an affectionate portrait that could be of any given community; it has many different qualities (including, as it is, gangs) that contribute to its unique flavor.
Similarly universal, if more than a little formulaic, is its story, which tracks a group of three friends over a span of 13 years. The main character is Mike (played as a teen by Sean Nelson, as an adult by Omar Epps), who moves to The Wood from North Carolina in 1986. In junior high he immediately clicks with Wood natives Roland (played as a teen by Trent Cameron, as an adult by Taye Diggs) and Slim (played as a teen by Duane Finley, as an adult by Richard T. Jones), and together they come of age through high school. As is with the case of all young men of the teen age, sex dominates the brain, and in a sense _The_Wood_ can be seen as a (slightly) less crass cousin to _American_Pie_; there are no outrageous gross-out gags, but the trio's attempts to initiate themselves are humorous in how they are so firmly grounded in honest reality.
As can be gleaned from the actor credits, there is also a parallel story that follows the trio as adults, and, unfortunately, it is not as interesting as the teenage story. In 1999, it's Roland's wedding day, and hours before the ceremony, he's nowhere to be found; Mike and Slim eventually do locate him, but he's plagued with doubt. The flashbacks are meant to punctuate the contemporary action, but the '99 scenes feel like needless interruptions in the story that runs through '86 and '89. This is no fault of the likable and charismatic actors, even if Epps is called on to address the camera directly for the film's first 15 minutes.
While I found that device to be distracting, it is in line with the theme of the film, which is this idea of community and belonging, which, of course, can be broken down to friendship. Over the course of _The_Wood_, one really grows to know and like these people as well as get a keen feeling of their place and time; by the film's final toast, one feels as if they are indeed part of The Wood.
Michael Dequina<EMAIL_ADDRESS>|<EMAIL_ADDRESS>|<EMAIL_ADDRESS>|<EMAIL_ADDRESS>Mr. Brown's Movie Site: http://welcome.to/mrbrown CompuServe Hollywood Hotline: http://www.HollywoodHotline.com on ICQ: #25289934 | on AOL Instant Messenger: MrBrown23
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


TEAM:
David Stanley
email:
<EMAIL_ADDRESS>Edward Richman
email:
<EMAIL_ADDRESS>Colin Arnott
email:
<EMAIL_ADDRESS>CLIENT:
Winston Howes
email:
winstonhowes@gmail.com


This tool was created in a collaboration with the Software Architectures for Socio-Cultural Systems (SORASCS) project, which itself is a collaboration between the Institute of Software Research (ISR) and the Center for Computational Analysis of Social and Organizational Systems (CASOS) at Carnegie Mellon University. The developers on this project were five full-time Master of Software Engineering (MSE) students known as "Team FACEO5."
For more information, please contact one of the project clients:


Countries by Population & Continent
Choose a Continent:
Africa
Antarctica
Asia
Europe
North America
Oceania
South America
Country Data
...


Gradient descent optimization algorithms are very popular to perform optimization and by far the most common way to optimize neural networks. However, there are also many other algorithms, like Hessian Free, Conjugate Gradient, BFGS, L-BFGS and etc., are proposed to deal with optimization tasks, here we only take those gradient descent methods into account. And we will discuss the drawbacks among those gradient algorithms and the methods to solve these blemishes.
Gradient Descent Optimization Algorithm
Vanilla Gradient Descent
Consider an objective $\mathcal{L}(\boldsymbol{\theta})$, and our goal is aiming to mimimize it. Here, the $\boldsymbol{\theta}\in\mathbb{R}^{n}$ is the set of parameters for entire dataset. Using (vanilla/batch) gradient descent, to minimize the objective, we need to update $\boldsymbol{\theta}$ by $$ \boldsymbol{\theta}:=\boldsymbol{\theta}-\eta\cdot\nabla_{\boldsymbol{\theta}}\mathcal{L}(\boldsymbol{\theta}) $$ where $\eta$ denotes learning rate, which determines the size of the steps we take to reach a (local) minimum, $\nabla_{\boldsymbol{\theta}}$ represents the partial derivative of $\mathcal{L}(\boldsymbol{\theta})$ with respect to $\boldsymbol{\theta}$, we can derive from the formula above that, for each update, the gradients for whole dataset need to be computed, which is extraordinarily time consuming and heavy memory occupation. Moreover, the batch gradient descent does not allow online training. Other drawbacks:
- It is relatively slow close to the minimum: technically, its asymptotic rate of convergence is inferior to many other methods. For poorly conditioned convex problems, gradient descent increasingly ‘zigzags’ as the gradients point nearly orthogonally to the shortest direction to a minimum point.
- It is only guaranteed to converge to the global minimum for convex error surfaces and to a local minimum for non-convex surfaces.
Vanilla gradient descent is OptimizationAlgorithm.LINE_GRADIENT_DESCENT
in DeepLearning4J.
Stochastic Gradient Descent
Stochastic gradient descent (often shortened in SGD), also known as incremental gradient descent, is a stochastic approximation of the gradient descent optimization method for minimizing an objective function. Unlike vanilla gradient descent, which performs redundant computations (since it may recompute gradients for similar examples before each parameter updates), SGD performs parameter update for each sample $(\mathbf{x}^{(i)},y^{(i)})$, i.e., it computes one update a time
$$
\boldsymbol{\theta}:=\boldsymbol{\theta}-\eta\cdot\nabla_{\boldsymbol{\theta}}\mathcal{L}_{i}(\boldsymbol{\theta})
$$
Thus, it is much faster than vanilla gradient descent and is capable of training online. Moreover, becasue of updating by one sample each time, SGD always perform frequent updates with a high variance that cause the objective function to fluctuate heavily. For SGD’s fluctuation, it may enable it to jump from a local minimum to new and potentially better local (even global) minima, however, this ultimately complicates convergence to the exact minimum, as SGD will keep overshooting. Besides, when the learning rate is slowly decreased, SGD shows the same convergence behaviour as batch gradient descent, almost certainly converging to a local or the global minimum for non-convex and convex optimization respectively. In deeplearning4j, Stochastic Gradient Descent is OptimizationAlgorithm.STOCHASTIC_GRADIENT_DESCENT
.
Mini-batch (Stochastic) Gradient Descent
Mini-batch (Stochastic) Gradient Descent performs an update for every $n$ training sample ($n=1$, it becomes an online method)
$$
\boldsymbol{\theta}:=\boldsymbol{\theta}-\eta\cdot\nabla_{\boldsymbol{\theta}}\mathcal{L}_{i:i+n}(\boldsymbol{\theta})
$$
it reduces the variance of the parameter updates, which can lead to more stable convergence and is able to make use of highly optimized matrix optimizations that make computing the gradient with respect to a mini-batch very efficient. Mini-batch gradient descent is typically the algorithm of choice when training a neural network and the term SGD usually is employed also when mini-batches are used. In deeplearning4j, by using mini-batch, set .miniBatch(true)
and the batch size is defined by data processor.
Albeit improvements are made to ameliorate gradient descent methods, there are still some challanges:
- Choosing a proper learning rate can be difficult. A learning rate that is too small leads to painfully slow convergence, while a learning rate that is too large can hinder convergence and cause the loss function to fluctuate around the minimum or even to diverge.
- Learning rate schedules try to adjust the learning rate during training by e.g. annealing, i.e. reducing the learning rate according to a pre-defined schedule or when the change in objective between epochs falls below a threshold. These schedules and thresholds, however, have to be defined in advance and are thus unable to adapt to a dataset’s characteristics.
- Additionally, the same learning rate applies to all parameter updates. If our data is sparse and our features have very different frequencies, we might not want to update all of them to the same extent, but perform a larger update for rarely occurring features.
- Another key challenge of minimizing highly non-convex error functions common for neural networks is avoiding getting trapped in their numerous suboptimal local minima. some argue that the difficulty arises in fact not from local minima but from saddle points, i.e. points where one dimension slopes up and another slopes down. These saddle points are usually surrounded by a plateau of the same error, which makes it notoriously hard for SGD to escape, as the gradient is close to zero in all dimensions.
Parameter Update Methods
Here I summarize some methods that are widely used in neural networks to deal with the aforementioned challanges.
Momentum
Since SGD has trouble navigating ravines, which are common around local optima. In these scenarios, SGD oscillates across the slopes of the ravine while only making hesitant progress along the bottom towards the local optimum. Momentum is a method, which appeared in Rumelhart, Hinton and Williams’ seminal paper on backpropagation learning, that helps to acclerate SGD in the relevant direction and dampens oscillations. Momentum remembers the update $\Delta w$ at each iteration, and determines the next update as a convex combination of the gradient and the previous update
$$
\begin{aligned}
\Delta w_{t} & :=\alpha\Delta w_{t-1}+\eta\nabla_{\boldsymbol{\theta}}\mathcal{L}(\boldsymbol{\theta})\newline
\boldsymbol{\theta} & :=\boldsymbol{\theta}-\Delta w_{t}
\end{aligned}
$$
where, $\alpha$ is a hyperparameter, which controls the contribution of the update vector of the past time step to the current update vector. The momentum term increases for dimensions whose gradients point in the same directions and reduces updates for dimensions whose gradients change directions. As a result, we gain faster convergence and reduced oscillation. Normally, the momentum term $\alpha$ is usually set to 0.9 or a similar value. In deeplearning4j, using momentum by setting .momentum(0.9)
.
Nesterov Momentum
Nesterov momentum, also know as Nesterov accelerated gradient (NAG), is a way to give the momentum term a kind of prescience that prevents the gradient blindly following the slope and let it knows where to go and then to slow down before the hill slopes up again.
$$
\begin{aligned}
\Delta w_{t} & :=\alpha\Delta w_{t-1}+\eta\nabla_{\boldsymbol{\theta}}\mathcal{L}(\boldsymbol{\theta}-\alpha\Delta w_{t-1})\newline
\boldsymbol{\theta} & :=\boldsymbol{\theta}-\Delta w_{t}
\end{aligned}
$$
where the $\eta$ denotes the learning rate, $\alpha$ denotes the momentum, computing $\boldsymbol{\theta}-\alpha\Delta w_{t-1}$ is to obtain an approximation of the next position of the parameters (the gradient is missing for the full update), a rough idea where the parameters are going to be.
See from the graph, while Momentum first computes the current gradient (small blue vector) and then takes a big jump in the direction of the updated accumulated gradient (big blue vector), NAG first makes a big jump in the direction of the previous accumulated gradient (brown vector), measures the gradient and then makes a correction (green vector). This anticipatory update prevents us from going too fast and results in increased responsiveness, which has significantly increased the performance of RNNs on a number of tasks. In deeplearning4j, Nesterov is .updater(Updater.NESTEROVS).momentum(0.9)
.
AdaGrad
AdaGrad (also know as adaptive gradient algorithm) is a modified stochastic gradient descent with per-parameter learning rate, it increases the learning rate (lager updates) for more sparse parameters and decreases the learning rate (smaller updates) for less sparse ones. This strategy often improves convergence performance over standard stochastic gradient descent for dealing with sparse data. In practice, AdaGrad greatly improved the robustness of SGD and it is often used for training large-scale neural nets, besides, GloVe model also use the AdaGrad.
Different from the above methods, who updates all parameters $\boldsymbol{\theta}$ at once and use the same learning rate for every parameter, however, AdaGrad uses a different learning rate for every parameter $\theta_{i}$ at every time step $t$. Denote $g_{t,i}$ to be the gradient of the objective function with respect to the parameter $\theta_{i}$ at time step $t$, then we have $g_{t,i}=\nabla_{\boldsymbol{\theta}}\mathcal{L}(\theta_{i})$, AdaGrad modifies the general learning rate $\eta$ at each time step $t$ for every parameter $\theta_{i}$ based on the previous gradients that have been computed for $\theta_{i}$:
$$
\theta_{t,i}:=\theta_{t-1,i}-\frac{\eta\cdot g_{t-1,i}}{\sqrt{G_{t-1,ii}+\epsilon}}:=\theta_{t-1,i}-\frac{\eta\cdot\nabla_{\boldsymbol{\theta}}\mathcal{L}(\theta_{i-1})}{\sqrt{G_{t-1,ii}+\epsilon}}
$$
where $G_{t}\in\mathbb{R}^{n\times n}$ is a diagonal matrix where each diagonal element is the sum of the squares of the gradients with respect to $\theta_{i}$ up to time step $t$, while $\epsilon$ is a smoothing term that avoids division by zero (usually takes $1e-8$). Thus, for $G_{t}$, which contains the sum of the squares of the past gradients with respect to all parameters $\boldsymbol{\theta}$ along its diagonal, so we have
$$
\boldsymbol{\theta}_{t}:=\boldsymbol{\theta}_{t-1}-\frac{\eta\cdot\nabla_{\boldsymbol{\theta}}\mathcal{L}(\theta)}{\sqrt{G_{t-1}+\epsilon}}
$$
Adagrad’s main benefits is that it eliminates the need to manually tune the learning rate. While, its main weakness is its accumulation of the squared gradients in the denominator, since every added term is positive, the accumulated sum keeps growing during training. This in turn causes the learning rate to shrink and eventually become infinitesimally small, at which point the algorithm is no longer able to acquire additional knowledge. In deeplearning4j, AdaGrad is Updater.ADAGRAD
.
AdaDelta
AdaDelta is an extension of AdaGrad that seeks to reduce the aggressive, monotonically decreasing learning rate of AdaGrad. Instead of accumulating all past squared gradients, Adadelta restricts the window of accumulated past gradients to some fixed size $win$.
Instead of inefficiently storing $win$ previous squared gradients, the sum of gradients is recursively defined as a decaying average of all past squared gradients. The running average $E[g^{2}]_{t}$ at time step $t$ then depends (as a fraction $\alpha$ similarly to the Momentum term) only on the previous average and the current gradient:
$$
E[g^{2}]_{t}=\alpha E[g^{2}]_{t-1}+(1-\alpha^{2})g_{t}^{2}
$$
From AdaGrad, we have
$$\Delta w_{t}=-\frac{\eta\cdot g_{t}}{\sqrt{G_{t}+\epsilon}}
$$
Now, simply replace the diagonal matrix $G_{t}$ with the decaying average over past squared gradients $E[g^{2}]_{t}$:
$$\Delta w_{t}=-\frac{\eta\cdot g_{t}}{\sqrt{E[g^{2}]_{t}+\epsilon}}=-\frac{\eta\cdot g_{t}}{RMS[g]_{t}}
$$
The authors note that the units in this update (as well as in SGD, Momentum, or Adagrad) do not match, i.e. the update should have the same hypothetical units as the parameter. To realize this, they first define another exponentially decaying average, this time not of squared gradients but of squared parameter updates:
$$
E[\Delta w^{2}]_{t}=\alpha\cdot E[\Delta w^{2}]_{t-1}+(1-\alpha)\Delta w_{t}^{2}
$$
The root mean squared error of parameter updates is thus:
$$
RMS[\Delta w]_{t}=\sqrt{E[\Delta w^{2}]_{t}+\epsilon}
$$
Since $RMS[\Delta w]_{t}$ is unknown, it is approximated with the RMS of parameter updates until the previous time step, replacing the learning rate $\eta$ in the previous update rule with $RMS[\Delta w]_{t-1}$, yields the Adadelta update rule:
$$
\begin{aligned}
\Delta w_{t} & =-\frac{RMS[\Delta w]_{t-1}}{RMS[g]_{t}}\cdot g_{t}\newline
\boldsymbol{\theta}_{t+1} & =\boldsymbol{\theta}_{t}+\Delta w_{t}
\end{aligned}
$$
With Adadelta, we do not even need to set a default learning rate, as it has been eliminated from the update rule. In deeplearning4j, AdaDelta is Updater.ADADELTA
.
RMSProp
RMSProp is another alternative to resolve AdaGrad’s radically diminishing learning rates, it is identical to the first update vector of AdaDelta
$$
\begin{aligned}
E[g^{2}]_{t} & :=0.9\cdot E[g^{2}]_{t-1}+0.1\cdot g_{t}^{2}\newline
\boldsymbol{\theta}_{t+1} & :=\boldsymbol{\theta}_{t}-\frac{\eta\cdot g_{t}}{\sqrt{E[g^{2}]_{t}+\epsilon}}
\end{aligned}
$$
RMSprop as well divides the learning rate by an exponentially decaying average of squared gradients. In practice, $\alpha$ equals to 0.9, and $\eta$ equals to 0.001 are good default values. In deeplearning4j, RMSProp is Updater.RMSPROP
.
Adam
Adaptive Moment Estimation (Adam) is another method that computes adaptive learning rates for each parameter. In addition to storing an exponentially decaying average of past squared gradients $v_{t}$, Adam also keeps an exponentially decaying average of past gradients $m_{t}$:
$$
\begin{aligned}
m_{t} & =\beta_{1}m_{t-1}+(1-\beta_{1})g_{t}\newline
v_{t} & =\beta_{2}v_{t-1}+(1-\beta_{2})g_{t}^{2}
\end{aligned}
$$
where $m_{t}$ and $v_{t}$ are estimates of the first moment (the mean) and the second moment (the uncentered variance) of the gradients respectively, then correcting the biaes by computing bias-corrected first and second moment estimates:
$$
\begin{aligned}
\hat{m}_{t} & =\frac{m_{t}}{1-\beta_{1}^{t}}\newline
\hat{v}_{t} & =\frac{v_{t}}{1-\beta_{2}^{t}}
\end{aligned}
$$
then use these to update the parameter yield the Adam update rule:
$$
\boldsymbol{\theta}_{t+1}=\boldsymbol{\theta}_{t}-\frac{\eta\cdot\hat{m}_{t}}{\sqrt{\hat{v}_{t}+\epsilon}}
$$
Normally, in practice, $\beta_{1}=0.9$, $\beta_{2}=0.999$ and $\epsilon=10^{-8}$. In deeplearning4j, Adam is Updater.ADAM
.
kSGD
Kalman-based Stochastic Gradient Descent (kSGD) is an online and offline algorithm for learning parameters from statistical problems from quasi-likelihood models, which include linear models, non-linear models, generalized linear models, and neural networks with squared error loss as special cases. The benefits of kSGD is not sensitive to the condition number of the problem and as a robust choice of hyperparameters as well as has a stopping condition. The drawbacks of kSGD is that the algorithm requires storing a dense covariance matrix between iterations, and requires a matrix-vector product at each iteration. More details please visit its Wikipedia – [link]
Conclusion
Generally, SGD is totally depends on the gradient of current batch, so it is hard to choose a reasonable learning rate, and it uses the same learning rate for all parameters, which is not suitable for sparse data/features. Moreover, SGD can be captured by local minimum easily or be trapped in saddle point.
Momentum is a way to speed up SGD, reduce oscillation and gain faster convergence. In the initial period, it uses the update parameter of last stage to keep the same descent diretion, and speed up by multiple a large $\alpha$ (momentum factor); In the middle and later periods, when the value osillates around the local minimum, and gradient tends to zero, it enlarges the update amplitude to jump out of the trap; What’s more, when the gradient changes the direction, it inhibits the update.
Nesterov plays a role of correction function when the gradient updates, which avoids the gradient goes forward too fast and increases the sensitivity.
AdaGrad acts as a constraint for learning rate. when the gradient is small in the initial period, the constraint term is large, which is able to magnify the gradient, and when the gradient is large in the later period, the constraint term is small, which restrains the gradient. And it is suitable for handling sparse gradient. However, it relys on the pre-set learning rate $\eta$, if the $\eta$ is too large, which makes contraint term hypersensitive, overamplifies the gradient in the initial period, and makes the gradient tends to zero in the later period and causes the training process terminates early.
AdaDelta is an improvement of AdaGrad, which has good acceleration effect in the prelimilary and middle periods, while in the later period, it ossilates at local minimum.
RMSProp can be treated as a particular case of AdaDelta, but it relys on the global learning rate. RMSProp is suitable for non-stationary target and performs well on RNNs.
Adam combines the merit of AdaGrad, which is good at dealing with sparse gradient, and the merit of RMSProp, which is good at handling non-stationary target, it uses different adaptive learning rates for different parameters. So it is suitable in most non-convex optimization and also appropriate for big dataset and high-dimensional space.
In summary, RMSprop is an extension of Adagrad that deals with its radically diminishing learning rates. It is identical to Adadelta, except that Adadelta uses the RMS of parameter updates in the numinator update rule. Adam, finally, adds bias-correction and momentum to RMSprop. Insofar, RMSprop, Adadelta, and Adam are very similar algorithms that do well in similar circumstances. Some researchers show that its bias-correction helps Adam slightly outperform RMSprop towards the end of optimization as gradients become sparser. Insofar, Adam might be the best overall choice (AdaMax and NAdam are two variants of Adam, which asserts that the performance is better than Adam).


--- layout: post title: 'Playframework: how to use moreScripts and moreStyles' date: '2013-02-05T23:52:00+01:00' tags: - playframework - java category: 'Programming' tumblr_url: http://andywenk.tumblr.com/post/42382652033/playframework-how-to-use-morescripts-and-morestyles ---
actually I am working with the http://www.playframework.org in a project. It is MVC web-framework written in Java. I like it because it’s simple to understand. Ok - maybe better if you already have experience with frameworks like Django or Rails.
What I did not understand a the first glimps is how to use moreScripts and moreStyles in main.html head:
But it’s quite simple because with get one receives the content of a variable and with set, like the name indicates, one sets the value of a variable. The only difference to the variable title in the title-tag above is the fact, that a helper method for JavaScript and CSS files is available. This helper is also setting the path to the files:
Example for moreScripts definition -> public/javascripts
Example for moreStyles definition -> public/stylesheets
Here is the documentation:
http://www.playframework.org/documentation/1.2.5
Meno, a colleague told not to use anything else than Playframework 1.2.5. So at this moment, I follow this advice ;-)
Cheers
Andy


Merkel party leader: No overhaul of German coalition deal
by The Associated PressBERLIN — The leader of German Chancellor Angela Merkel’s party is rejecting calls for an overhaul of the accord underpinning Merkel’s often-fractious coalition government.
Merkel’s centre-right Union bloc leads an alliance with the centre-left Social Democrats. Halfway through the parliamentary term, the Social Democrats are choosing a new leadership and are expected to decide next month whether to stay in the coalition.
One Social Democratic leadership contender has advocated an overhaul of the coalition accord drawn up last year, as has a prominent lawmaker in Merkel’s Christian Democratic Union.
But CDU leader Annegret Kramp-Karrenbauer has made clear ahead of a party conference this week that she’s not interested. Kramp-Karrenbauer told Sunday’s edition of the Welt am Sonntag newspaper: “The coalition agreement is valid, and it most certainly will not be renegotiated.”
The Associated Press


The TF727 is a heavy duty 3 speed automatic transmission used in heavy duty Dodge trucks. The case is 16" long and 14 bolts hold in the pan. Transmission 1st 2nd 3rd 4th 5th Rev TF 727 2.45 1.45 1.00 NA
The TF727 is a heavy duty 3 speed automatic transmission used in heavy duty Dodge trucks. The case is 16" long and 14 bolts hold in the pan.


Pete Samu extends contract with Brumbies and Rugby Australia
by Online EditorsWallabies back-rower Pete Samu has signed a two-year extension to his Rugby Australia and Brumbies contract.
Samu, who returned to Australia and joined the Brumbies from the Crusaders ahead of the 2019 season, has extended his stay with the club until 2022.
It helps the Canberra-based side consolidate their back-row stocks after the departure of David Pocock, who has headed overseas.
Continue reading below…
After huge success with the Crusaders, the 27-year-old Samu has won the Australian Conference and reached the semi-finals of Super Rugby since joining the Brumbies, and made his Wallabies debut against Ireland in June 2018.
Offering versatility across all three back-row positions, Samu played 958 minutes in his first campaign with the Brumbies, crossing for five tries and making 579 metres from 74 carries.
Having missed out on the Wallabies squad for the Rugby World Cup, Samu will be targeting a return to the international squad.
“I am very excited by the opportunity to extend my current Brumbies contract and commit myself to the Brumbies for the next three years,” he said.
“I feel I have settled in well in Canberra and I have enjoyed every minute of my time here.
“We have a strong bond within our playing group and a lot of quality in every position and I am looking forward to being able to contribute towards the club’s success.”
AAP
In other news:


{% extends 'base.html' %} {% block header %}
It doesn't look like you are logged in yet. Click here to log in or here to register if you haven't already.
{% elif runs is not defined %}It doesn't look like you have any runs yet. Click here to get started!
{% else %}| Name | Format | Start Time | Last Updated | Status | Refresh Status | Download Data | Get More Data | Visualize Results | Continue Training | Delete | ||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
| {{ run.title }} | {{ run.format }} | {{ moment(timestamp=run.start_time, local=True).calendar() }} | {{ moment(timestamp=run.update_time, local=True).fromNow() }} | {{ run.descr }} | Refresh | {% if 'Data available' in run.descr %}{% else %} | ---- | ---- | ---- | ---- | {% endif %}Delete |


It is time for the happy moment to share your app with others. For testing, for sharing with friends, or for publishing on the app stores.
To make an Evothings app available to others, you have the following options:
Share your app with Evothings Viewer. Put your HTML and JavaScript files on a web server and run the app using Evothings Viewer (estimated time 15 minutes).
Build a native app with Apache Cordova. Install Cordova and build your app (estimated time 2 - 8 hours). Then publish it on the app stores (estimated time 4 - 16 hours depending on which app stores you target).
Building and publishing a native app takes some effort. If you wish to share an app in the quickest possible way, it is recommended that you go for the first option. Start out easy and deploy your app on a web server, then run it from Evothings Viewer.
When you are ready for app store publication, learn how to build native apps with Cordova.
Apache Cordova is a build system for creating native apps with bundled HTML and JavaScript content. Apps built with Cordova are native apps that can be published on the app stores. Furthermore, you can add plugins to extend your app with native functionality.
The following are the steps to make a native app:
Install Cordova
Create a Cordova project and build a native app
Publish the app
First step is to install Cordova. Here are installation guides for different platforms:
The Cordova install procedure and command line tools are also described in the Cordova documentation.
When you have Cordova installed, you can build a native app. Read the Evothings Cordova Guide to find out how to create and build a Cordova app and how to use Cordova with Evothings Studio. You can also consult the Cordova documentation.
Final step is to publish the app on the app stores:
Supported mobile platforms for Evothings are iOS and Android.
Cordova comes with a set of plugins that are supported for a wide range of platforms. Evothings apps can use custom plugins available for iOS and Android. As long as you do not require socket communication or BLE, you should be able to use Evothings Studio to build apps for any platform supported by Cordova.
The same goes for Evothings Viewer. It is available on iOS and Android, but should be possible to build from source for any platform supported by Cordova. (But you would miss the plugins not available for the target platform.)
Evothings Viewer is itself built with Cordova. It is a plain Cordova app with native plugins added, e.g. for socket communication and Bluetooth Low Energy (BLE).


Bayelsa Polls: DSP Omo-Agege assures of future wins in South South
Elo Edremoda, Warri
Deputy Senate President, Senator Ovie Omo-Agege, has described the All Progressives Congress (APC), victory in Bayelsa State as an assurance that more South-South states will be won by the party in future elections.
Omo-Agege stated this in a congratulatory message to the governor-elect of the state, Chief David Lyon.
The statement which was issued by his special adviser, media and publicity, Mr. Yomi Odunuga, said that the APC’s win further confirms the party’s success at the last general elections.
He commended the national and state leadership of the party, particularly the National Chairman, Comrade Adams Oshiomhole, Minister of State for Petroleum, Timipre Sylva, Jigawa State Governor and Chairman of the APC campaign council for the Bayelsa governorship election, Abubakar Badaru, for their contributions to the landslide success recorded at the polls.
He also expressed appreciation to the people of Bayelsa state for the confidence reposed in the party and its candidate, assuring that they will not be disappointed.
The final election results announced by the Independent National Electoral Commission (INEC) early hours of Monday, had declared David Lyon of the APC winner of the gubernatorial polls, with 352,552 votes, defeating the candidate of the People’s Democratic Party, Senator Duoye Diri, who scored 143,172 votes.
READ ALSO: We knew we’ll win Kogi, Bayelsa polls, says APC
Omo-Agege stated: “with this development and the actualisation of the Next Level Agenda of the APC-led administration, it is certain that our party will clinch more states in the South-South geo-political zone in future elections.
“Like I have always said, it is possible for the APC to rule in the South-South beyond Edo State. And I have been proven right with the final results from Bayelsa State.
“This goes to show that with determination and tenacity of purpose, we can overcome what seems insurmountable.
“I, once again, congratulate David Lyon, the governor-elect of Bayelsa State.”


Pistol Shrimp is a net label project me and a group of colleagues developed while having in mind the impact of the internet on musical distribution.
It’s main focus is the role an interactive experience can portray in order to engage the listener / user during the experience of music and visual stimuli.
All the releases came with an interactive momentum, similar to a game level where the purpose is to find out the download.
The
Interactive Dancefloor was also a piece developed inside this project, where the creation of a life-size out of the screen experience embodies a space where people can stand on and generate sound.
This was a team project done by me (Mariana Freitas), João Rodrigues, Margarida Botelho and Sandrina Pereira.


{% extends "base.html" %} {% block dropdown %} {% endblock %} {% block content %}
| Name: | {{ excuse.brother.first_name }} {{ excuse.brother.last_name }} |
| Event: | {{ excuse.event.name }} |
| Event Date: | {{ excuse.event.date }} |
| Date Submitted: | {{ excuse.date_submitted }} |
| Event Mandatory: | {{ excuse.event.mandatory }} |
| Excuse Reason: | {{ excuse.description }} |
| Excuse Status: | Pending |
| Excuse Status: | Approved |
| Excuse Status: | Denied |
| Response: | {{ excuse.response_message }} |
| Edit Excuse |


Puneeth N Naik
I am Puneeth N Naik, a student with a lifelong interest in learning and applying computer science. I have a keen interest in open source. I share my knowledge here.


You can reach at: {{email}}
Address: {{address.street}} {{address.city}}, {{address.state}}
{{ user.email }}


Sample Example - HelloWorldService¶
Here we demonstrate how a Provider can use KubePlus to deliver a “hello-world as-a-Service” using a Hello World Helm chart. The helm chart defines a Deployment and a Service. The Pod managed by the Deployment prints the messages that are provided as input. When registering the service, Provider defines the CPU and Memory requests and limits that should be provided to the HelloWorld Pod. KubePlus ensures that every HelloWorldService instance Pod is given the CPU and Memory requests and limits that are configured by the Provider when registering the HelloWorldService. Consumers create HelloWorldService instances and pass custom hello messages to print to the Pod.
Setup¶
In order to try this example you will need to install Kubernetes CLI (kubectl), or if you are using OpenShift, the OpenShift CLI (oc). Choose the CLI version that works with your Kubernetes version. Once the appropriate CLI is installed, follow these steps.
Open three command terminal windows. Name them as:
Cluster admin window
Provider window
Consumer window
Both cluster admin and provider will need to use KubePlus kubectl plugins.
Install KubePlus kubectl plugins
curl -L https://github.com/cloud-ark/kubeplus/raw/master/kubeplus-kubectl-plugins.tar.gz -o kubeplus-kubectl-plugins.tar.gz
gunzip kubeplus-kubectl-plugins.tar.gz
tar -xvf kubeplus-kubectl-plugins.tar
export KUBEPLUS_HOME=`pwd`
export PATH=$KUBEPLUS_HOME/plugins/:$PATH
kubectl kubeplus commands
or
oc kubeplus commands
Cluster Admin actions¶
1. Install KubePlus
Set KUBEPLUS_NS environment variable to the NAMESPACE in which you have installed KubePlus. For OpenShift users, the namespace needs to be ‘openshift-operators’.
KUBEPLUS_NS=<Namespace>
Make sure KubePlus Pod is running (Status should be ‘RUNNING’ and all 5 containers).
kubectl get pods -n $KUBEPLUS_NS
If KubePlus Pod is not running then install KubePlus first.
2. Get provider and consumer kubeconfigs
KubePlus generates separate kubeconfig files for provider and consumers with appropriate permissions. You would have generated provider kubeconfig (kubeplus-saas-provider.json) as part of installing KubePlus Operator. Retrieve KubePlus consumer kubeconfig as follows:
$ kubectl retrieve kubeconfig consumer $KUBEPLUS_NS > consumer.conf
In the steps below, use the appropriate kubeconfig in the provider and consumer actions by passing the --kubeconfig=<provider/consumer kubeconfig file>
flag.
Provider action¶
1. Register HelloWorldService
Create hello-world-resource-composition:
Create HelloWorldService consumer API. Here is the hello-world-resource-composition.yaml file. Save it as hello-world-resource-composition.yaml.
apiVersion: workflows.kubeplus/v1alpha1
kind: ResourceComposition
metadata:
name: hello-world-resource-composition
spec:
# newResource defines the new CRD to be installed define a workflow.
newResource:
resource:
kind: HelloWorldService
group: platformapi.kubeplus
version: v1alpha1
plural: helloworldservices
# URL of the Helm chart that contains Kubernetes resources that represent a workflow.
chartURL: https://github.com/cloud-ark/operatorcharts/blob/master/hello-world-chart-0.0.2.tgz?raw=true
chartName: hello-world-chart
# respolicy defines the resource policy to be applied to instances of the specified custom resource.
respolicy:
apiVersion: workflows.kubeplus/v1alpha1
kind: ResourcePolicy
metadata:
name: hello-world-service-policy
spec:
resource:
kind: HelloWorldService
group: platformapi.kubeplus
version: v1alpha1
policy:
# Add following requests and limits for the first container of all the Pods that are related via
# owner reference relationship to instances of resources specified above.
podconfig:
limits:
cpu: 200m
memory: 2Gi
requests:
cpu: 100m
memory: 1Gi
# resmonitor identifies the resource instances that should be monitored for CPU/Memory/Storage.
# All the Pods that are related to the resource instance through either ownerReference relationship, or all the relationships
# (ownerReference, label, annotation, spec properties) are considered in calculating the statistics.
# The generated output is in Prometheus format.
resmonitor:
apiVersion: workflows.kubeplus/v1alpha1
kind: ResourceMonitor
metadata:
name: hello-world-service-monitor
spec:
resource:
kind: HelloWorldService
group: platformapi.kubeplus
version: v1alpha1
# This attribute indicates that Pods that are reachable through all the relationships should be used
# as part of calculating the monitoring statistics.
monitorRelationships: all
The respolicy
section in the resource composition defines the ResourcePolicy
that the provider configures for this service. Here it defines the cpu and memory requests and limits that need to be configured for service instances of this service.
Create hello-world-resource-composition as follows:
kubectl create -f hello-world-resource-composition.yaml -n $KUBEPLUS_NS --kubeconfig=kubeplus-saas-provider.json
or
oc create -f hello-world-resource-composition.yaml -n $KUBEPLUS_NS --kubeconfig=kubeplus-saas-provider.json
Wait till HelloWorldService CRD is registered in the cluster.
until kubectl get crds --kubeconfig=kubeplus-saas-provider.json | grep hello ; do echo "Waiting for HelloworldService CRD to be registered.."; sleep 1; done
or
until oc get crds --kubeconfig=kubeplus-saas-provider.json | grep hello ; do echo "Waiting for HelloworldService CRD to be registered.."; sleep 1; done
Grant permission to the consumer to create service instances.
kubectl grantpermission consumer helloworldservices kubeplus-saas-provider.json $KUBEPLUS_NS
Consumer actions¶
1. Create HelloWorldService instance
HelloWorldService instances can be created using either kubectl or consumer ui that KubePlus provides.
Using Consumer UI
The consumer UI is part of KubePlus and runs on the cluster. Access it as follows:
$ wget https://raw.githubusercontent.com/cloud-ark/kubeplus/master/deploy/open-consumer-ui.sh
$ chmod +x open-consumer-ui.sh
$ ./open-consumer-ui.sh consumer.conf
The HelloWorldService will be available at following URL:
$ http://localhost:5000/service/HelloWorldService
If you are working with the KubePlus Vagrant VM, access the service at following URL:
$ http://<IP_ADDRESS>:5000/service/HelloWorldService
The UI provides a form to input values that need to be provided when creating a service instance. You can also check the API documentation for the service on the UI. Because the cluster admin has granted permission to the consumer to create the HelloWorldService instances, you will be able to create an instance of HelloWorldService through the UI. Here are the screenshots of using Consumer UI.
Check API Doc
Create instance - KubePlus generates a form corresponding to the fields defined in the underlying chart’s values.yaml file.
Created instance details
Using CLI
Check the HelloWorldService API documentation
kubectl man HelloWorldService -k consumer.conf
You should see following output:
KIND: HelloWorldService
GROUP: platformapi.kubeplus
VERSION: v1alpha1
DESCRIPTION:
Here is the values.yaml for the underlying Helm chart representing this resource.
The attributes in values.yaml become the Spec properties of the resource.
::::::::::::::
/hello-world-chart/values.yaml
::::::::::::::
# Default value for namespace.
greeting: Hello World!
Create HelloWorldService instance:
Copy below YAML and save it as hello-world-service.yaml
apiVersion: platformapi.kubeplus/v1alpha1
kind: HelloWorldService
metadata:
name: hs1
spec:
greeting: Hello hello hello
kubectl create -f hello-world-service.yaml --kubeconfig=consumer.conf
or
oc create -f hello-world-service.yaml --kubeconfig=consumer.conf
This will create hs1 instance in the default namespace.
Check if the service instance has been created:
kubectl get helloworldservices --kubeconfig=consumer.conf
kubectl describe helloworldservices hs1 --kubeconfig=consumer.conf
or
oc get helloworldservices --kubeconfig=consumer.conf
oc describe helloworldservices hs1 --kubeconfig=consumer.conf
Verify that the Status field is populated in hs1 instance.
Verify that HelloWorldService has been started
HELLOWORLD_POD=`kubectl get pods -A | grep hello-world-deployment-helloworldservice | awk '{print $2}'`
HELLOWORLD_NS=`kubectl get pods -A | grep hello-world-deployment-helloworldservice | awk '{print $1}'`
kubectl port-forward $HELLOWORLD_POD -n $HELLOWORLD_NS 8082:5000 &
curl localhost:8082
or
HELLOWORLD_POD=`oc get pods -A | grep hello-world-deployment-helloworldservice | awk '{print $2}'`
HELLOWORLD_NS=`oc get pods -A | grep hello-world-deployment-helloworldservice | awk '{print $1}'`
oc port-forward $HELLOWORLD_POD -n $HELLOWORLD_NS 8082:5000 &
curl localhost:8082
You should see following output:
Hello hello hello
Provider actions (cont.)¶
On the provider window, perform following steps:
Install Docker and verify that you are able to run docker commands without requiring sudo.
docker ps
This should return without any errors.
1. Monitor HelloWorldService instance
HELLOWORLD_NS=`kubectl get pods -A --kubeconfig=kubeplus-saas-provider.json | grep hello-world-deployment-helloworldservice | awk '{print $1}'`
or
HELLOWORLD_NS=`oc get pods -A --kubeconfig=kubeplus-saas-provider.json | grep hello-world-deployment-helloworldservice | awk '{print $1}'`
kubectl metrics HelloWorldService hs1 $HELLOWORLD_NS -k kubeplus-saas-provider.json -o prometheus
You should see output of the following form:
2. Verify resource requests and limits have been set on the Pod that belongs to HelloWorldService instance
kubectl get pods $HELLOWORLD_POD -n $HELLOWORLD_NS -o json --kubeconfig=kubeplus-saas-provider.json | jq -r '.spec.containers[0].resources'
or
oc get pods $HELLOWORLD_POD -n $HELLOWORLD_NS -o json --kubeconfig=kubeplus-saas-provider.json | jq -r '.spec.containers[0].resources'
You should see following output:
3. Check resource relationship graph for HelloWorldService instance
kubectl connections HelloWorldService hs1 $KUBEPLUS_NS -k kubeplus-saas-provider.json
or
oc connections HelloWorldService hs1 $KUBEPLUS_NS -k kubeplus-saas-provider.json
You should see following output:
4. Visualize the relationship graph
kubectl connections HelloWorldService hs1 $KUBEPLUS_NS -o png -k kubeplus-saas-provider.json
or
oc connections HelloWorldService hs1 $KUBEPLUS_NS -o png -k kubeplus-saas-provider.json


To delete an existing class, click on the Class Wizard button in the toolbar , or select Object / Class Wizard... from the main menu. Select the class you want to delete and click on the Delete... button.
Note: The changes will only apply to the current file.
For more information, see the Class Wizard topic.


cma.evolution_strategy._CMASolutionDict(dict)
class documentationcma.evolution_strategy
(View In Hierarchy)
| Method | insert | Undocumented |
| Method | get | Undocumented |
| Method | __getitem__ | Undocumented |
| Method | __setitem__ | Undocumented |


webmachine
How do I get started?
If you want to jump in and start coding right away, the quickstart is the way to go.
If you would prefer to watch a narrated slideshow introduction, this is roughly similar to the presentation that was given at Bay Area Erlang Factory 2009:
Some blogs also have posts that can serve as useful introductions to Webmachine, if you prefer to start that way.
No matter how you get started, you'll probably want to come back and read more documentation once you get up and running.