MACI uses Experiment Study Templates to create Experiment Studies consisting of multiple Experiments, as shown in Figure 1.
MACI provides a Web Frontend, a Backend system consisting of a dotnet core management component and a jupyter notebook for data analysis, and Worker instances to scale experiment execution.
The folder {{datalocation}}
contains the following files which are managed by MACI:
The subfolder ExperimentTemplates/X/framework contains all required experiment files which are not managed by MACI, e.g., your actual application code. You might add all stuff you want to ship with your experiments.
ExperimentTemplates/ example/ .git/ script.py install.py update_maci.bat (optional) configurations/ default.json e.g. my_other_config.json framework/ e.g. example.progmp ExperimentFramework/ e.g. helper.py
Change your backend database in maci_backend/appsettings.json
. Use either sqlite (default) or postgres.
The following steps are executed by MACI whenever you create a new experiment. These steps enable you to customize MACI.
/ExperimentTemplates/X/update_maci.sh
if available. This might be used to pull from git repositories./ExperimentTemplates/X/framework/* to /Experiments/Y
. Thus, all experiments of an experiment study use the same copy.


This is a UI5 Web Components date picker
Load OpenUI5
OpenUI5 app (sap.m.DatePicker) to be loaded here...


Rigid bodies are the basic unit of simulation in Chipmunk. More...
#import <ChipmunkBody.h>
Inherits ChipmunkBaseObject-p.
Public Member Functions | |
| (id) | - initWithMass:andMoment: |
| Initialize a rigid body with the given mass and moment of inertia. | |
| (id) | - initStaticBody |
| Initialize a rigid body with infinite mass and moment. | |
| (cpVect) | - local2world: |
| Convert from body local to world coordinates. | |
| (cpVect) | - world2local: |
| Convert from world to body local Coordinates. | |
| (void) | - resetForces |
| Reset force and torque. | |
| (void) | - applyForce:offset: |
| Apply a force to a rigid body. | |
| (void) | - applyImpulse:offset: |
| Apply an impulse to a rigid body. | |
| (void) | - activate |
| Wake up the body if it's sleeping, or reset the idle timer if it's active. | |
| (void) | - sleep |
| Force the body to sleep immediately. | |
| (void) | - addToSpace: |
| Implements the ChipmunkBaseObject protocol, not particularly useful outside of the library code. | |
| (void) | - removeFromSpace: |
| Implements the ChipmunkBaseObject protocol, not particularly useful outside of the library code. | |
| (CGAffineTransform) | - affineTransform |
| Get an affine transform to match this body. | |
Static Public Member Functions | |
| (id) | + bodyWithMass:andMoment: |
| Create an autoreleased rigid body with the given mass and moment. | |
| (id) | + staticBody |
| Create an autoreleased rigid body with infinite mass and moment. | |
Properties | |
| cpFloat | mass |
| Mass of the rigid body. Mass does not have to be expressed in any particular units, but relative masses should be consistent. | |
| cpFloat | moment |
| Moment of inertia of the body. The mass tells you how hard it is to push an object, the MoI tells you how hard it is to spin the object. Don't try to guess the MoI, use the cpMomentFor*() functions to try and estimate it. | |
| cpVect | pos |
| The position of the rigid body's center of gravity. | |
| cpVect | vel |
| The linear velocity of the rigid body. | |
| cpVect | force |
| The linear force applied to the rigid body. Unlike in some physics engines, the force does not reset itself during each step. Make sure that you are reseting the force between frames if that is what you intended. | |
| cpFloat | angle |
| The rotation angle of the rigid body in radians. | |
| cpFloat | angVel |
| The angular velocity of the rigid body in radians per second. | |
| cpFloat | torque |
| The torque being applied to the rigid body. Like force, this property is not reset every frame. | |
| cpVect | rot |
| A unit length vector vector that stores the current rotation of the body as a 2D spinor or complex number. Can be used for fast rotation. | |
| cpBody * | body |
| Returns a pointer to the underlying cpBody C struct. | |
| id | data |
| An object that this constraint is associated with. | |
| bool | isSleeping |
| Has the body been put to sleep by the space? | |
| bool | isRogue |
| Has the body not been added to any spaces? | |
| bool | isStatic |
| Is the body the static body associated with a space? |
Rigid bodies are the basic unit of simulation in Chipmunk.
They hold the physical properties of an object (mass, position, rotation, velocity, etc.). After creating a ChipmunkBody object, you can attach collision shapes (ChipmunkShape) and joints (ChipmunkConstraint) to it.
| - (void) applyForce: | (cpVect) | force | ||
| offset: | (cpVect) | offset | ||
Apply a force to a rigid body.
An offset of cpvzero is equivalent to adding directly to the force property.
| force | A force in expressed in absolute (word) coordinates. | |
| offset | An offset expressed in world coordinates. Note that it is still an offset, meaning that it's position is relative, but the rotation is not. |
| - (void) applyImpulse: | (cpVect) | impulse | ||
| offset: | (cpVect) | offset | ||
Apply an impulse to a rigid body.
| impulse | An impulse in expressed in absolute (word) coordinates. | |
| offset | An offset expressed in world coordinates. Note that it is still an offset, meaning that it's position is relative, but the rotation is not. |
| + (id) bodyWithMass: | (cpFloat) | mass | ||
| andMoment: | (cpFloat) | moment | ||
Create an autoreleased rigid body with the given mass and moment.
Guessing the moment of inertia is usually a bad idea. Use the moment estimation functions (cpMomentFor*()).
| - (id) initStaticBody |
Initialize a rigid body with infinite mass and moment.
This is most useful when you want to create a rogue body for controlling a moving platform or some other strictly controlled object.
| - (id) initWithMass: | (cpFloat) | mass | ||
| andMoment: | (cpFloat) | moment | ||
Initialize a rigid body with the given mass and moment of inertia.
Guessing the moment of inertia is usually a bad idea. Use the moment estimation functions (cpMomentFor*()).
| - (cpVect) local2world: | (cpVect) | v |
Convert from body local to world coordinates.
Convert a point in world (absolute) coordinates to body local coordinates affected by the position and rotation of the rigid body.
| - (void) resetForces |
Reset force and torque.
Set the force on this rigid body to cpvzero, and set the torque to 0.0.
| - (void) sleep |
Force the body to sleep immediately.
Make sure the body is fully set up before you call this. Adding this body or any shapes attached to it, or modifying any of the body's properties will reactivate it. This is useful if you want an object to be inactive until something hits it such as a pile of boxes you want the player to plow through or a stalactite hanging from a cave ceiling.
| + (id) staticBody |
Create an autoreleased rigid body with infinite mass and moment.
This is most useful when you want to create a rogue body for controlling a moving platform or some other strictly controlled object.
| - (cpVect) world2local: | (cpVect) | v |
Convert from world to body local Coordinates.
Convert a point in body local coordinates coordinates to world (absolute) coordinates.
- (id) data [read, write, assign] |
An object that this constraint is associated with.
You can use this get a reference to your game object or controller object from within callbacks.
delegate
properties this is a weak reference and does not call retain
. This prevents reference cycles from occuring.


| Modifier and Type | Method and Description |
|---|---|
static Item |
EwsUtilities.createItemFromItemClass(ItemAttachment itemAttachment,
Class<?> itemClass,
boolean isNew)
Creates the item from item class.
|
static Item |
EwsUtilities.createItemFromXmlElementName(ItemAttachment itemAttachment,
String xmlElementName)
Creates the item from xml element name.
|
| Modifier and Type | Method and Description |
|---|---|
Object |
ICreateServiceObjectWithAttachmentParam.createServiceObjectWithAttachmentParam(ItemAttachment itemAttachment,
boolean isNew)
Creates the service object with attachment param.
|
| Modifier and Type | Method and Description |
|---|---|
ItemAttachment |
Item.getParentAttachment()
Gets the parent attachment of this item.
|
| Constructor and Description |
|---|
Appointment(ItemAttachment parentAttachment,
boolean isNew)
Initializes a new instance of Appointment.
|
Contact(ItemAttachment parentAttachment)
Initializes a new instance of the
Contact class. |
ContactGroup(ItemAttachment parentAttachment)
Initializes an new instance of the class.
|
EmailMessage(ItemAttachment parentAttachment)
Initializes a new instance of the "EmailMessage" class.
|
Item(ItemAttachment parentAttachment)
Initializes a new instance of the item class.
|
MeetingCancellation(ItemAttachment parentAttachment)
Initializes a new instance of the class.
|
MeetingMessage(ItemAttachment parentAttachment)
Initializes a new instance of the "MeetingMessage" class.
|
MeetingRequest(ItemAttachment parentAttachment)
Initializes a new instance of the class.
|
MeetingResponse(ItemAttachment parentAttachment)
Initializes a new instance of the class.
|
PostItem(ItemAttachment parentAttachment)
Initializes a new instance of the class.
|
Task(ItemAttachment parentAttachment)
Initializes a new instance of the class.
|
| Modifier and Type | Class and Description |
|---|---|
class |
GenericItemAttachment<TItem extends Item>
Represents a strongly typed item attachment.
|


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Packages that use Node | |
|---|---|
| org.dom4j | Defines the XML Document Object Model in Java interfaces together with some helper classes. |
| org.dom4j.datatype | An implementation of the dom4j API which supports the XML Schema Data Types specification. |
| org.dom4j.io | Provides input and output via SAX and DOM together with writing dom4j objects to streams as XML text. |
| org.dom4j.rule | A Pattern based XML rule engine which implements
the full XSLT processing model while allowing any Action
to be fired if a pattern matches. |
| org.dom4j.tree | Contains the default implementations of the dom4j Document Object Model together with some helpful base classes for those wishing to implement their own document object model. |
| org.dom4j.util | A collection of utility classes for the dom4j API. |
| Uses of Node in org.dom4j |
|---|
| Subinterfaces of Node in org.dom4j | |
|---|---|
interface |
Attribute
Attribute defines an XML attribute. |
interface |
Branch
Branch interface defines the common behaviour for Nodes which
can contain child nodes (content) such as XML elements and documents. |
interface |
CDATA
CDATA defines an XML CDATA section. |
interface |
CharacterData
CharacterData is a marker interface for character based nodes
such as the CDATA ,Comment and
Text nodes. |
interface |
Comment
Comment defines the behavior of an XML comment. |
interface |
Document
Document defines an XML Document. |
interface |
DocumentType
DocumentType defines an XML DOCTYPE declaration. |
interface |
Element
Element interface defines an XML element. |
interface |
Entity
Entity defines an XML entity. |
interface |
ProcessingInstruction
ProcessingInstruction defines an XML processing instruction. |
interface |
Text
Text defines an XML Text node. |
| Classes in org.dom4j that implement Node | |
|---|---|
class |
Namespace
Namespace is a Flyweight Namespace that can be shared amongst
nodes. |
| Methods in org.dom4j that return Node | |
|---|---|
Node |
Node.asXPathResult(Element parent)
asXPathResult returns a version of this node which is
capable of being an XPath result. |
protected Node |
Namespace.createXPathResult(Element parent)
|
Node |
Node.detach()
Removes this node from its parent if there is one. |
Node |
Element.getXPathResult(int index)
Returns a node at the given index suitable for an XPath result set. |
Node |
Branch.node(int index)
Returns the Node at the specified index position. |
Node |
XPath.selectSingleNode(java.lang.Object context)
selectSingleNode evaluates this XPath expression on the
given Node or List of Node s and returns the
result as a single Node instance. |
Node |
Node.selectSingleNode(java.lang.String xpathExpression)
selectSingleNode evaluates an XPath expression and returns
the result as a single Node instance. |
| Methods in org.dom4j with parameters of type Node | |
|---|---|
void |
Branch.add(Node node)
Adds the given Node or throws IllegalAddException
if the given node is not of a valid type. |
int |
Branch.indexOf(Node node)
Returns the index of the given node if it is a child node of this branch or -1 if the given node is not a child node. |
boolean |
NodeFilter.matches(Node node)
matches returns true if the given node matches the filter
condition. |
boolean |
XPath.matches(Node node)
matches returns true if the given node matches the XPath
expression. |
boolean |
Branch.remove(Node node)
Removes the given Node if the node is an immediate child
of this branch. |
static java.util.List |
DocumentHelper.selectNodes(java.lang.String xpathFilterExpression,
Node node)
selectNodes performs the given XPath expression on the
List of Node instances appending all the results together
into a single list. |
| Constructors in org.dom4j with parameters of type Node | |
|---|---|
IllegalAddException(Branch parent,
Node node,
java.lang.String reason)
|
|
IllegalAddException(Element parent,
Node node,
java.lang.String reason)
|
| Uses of Node in org.dom4j.datatype |
|---|
| Classes in org.dom4j.datatype that implement Node | |
|---|---|
class |
DatatypeAttribute
DatatypeAttribute represents an Attribute which supports the
XML Schema Data Types
specification. |
class |
DatatypeElement
DatatypeElement represents an Element which supports the XML Schema Data Types
specification. |
| Methods in org.dom4j.datatype with parameters of type Node | |
|---|---|
protected void |
DatatypeElement.childAdded(Node node)
Override to force lazy recreation of data object |
protected void |
DatatypeElement.childRemoved(Node node)
Override to force lazy recreation of data object |
| Uses of Node in org.dom4j.io |
|---|
| Methods in org.dom4j.io that return Node | |
|---|---|
Node |
STAXEventReader.readNode(javax.xml.stream.XMLEventReader reader)
Reads a Node from the event stream. |
| Methods in org.dom4j.io with parameters of type Node | |
|---|---|
void |
XMLWriter.write(Node node)
Writes the given Node . |
void |
SAXWriter.write(Node node)
A polymorphic method to write any Node to this SAX stream |
protected void |
XMLWriter.writeNode(Node node)
|
void |
STAXEventWriter.writeNode(Node n)
Writes a DOM4J Node to the stream. |
protected void |
XMLWriter.writeNodeText(Node node)
This method is used to write out Nodes that contain text and still allow for xml:space to be handled properly. |
| Constructors in org.dom4j.io with parameters of type Node | |
|---|---|
DocumentSource(Node node)
Creates a JAXP SAXSource for the given Node . |
| Uses of Node in org.dom4j.rule |
|---|
| Methods in org.dom4j.rule with parameters of type Node | |
|---|---|
void |
Mode.fireRule(Node node)
Runs the actions associated with the given node |
Rule |
Mode.getMatchingRule(Node node)
Performs an XSLT processing model match for the rule which matches the given Node the best. |
Rule |
RuleSet.getMatchingRule(Node node)
Performs an XSLT processing model match for the rule which matches the given Node the best. |
Rule |
RuleManager.getMatchingRule(java.lang.String modeName,
Node node)
Performs an XSLT processing model match for the rule which matches the given Node the best. |
boolean |
Rule.matches(Node node)
DOCUMENT ME! |
boolean |
Pattern.matches(Node node)
DOCUMENT ME! |
void |
NullAction.run(Node node)
|
void |
Action.run(Node node)
|
void |
Stylesheet.run(Node node)
|
void |
Stylesheet.run(Node node,
java.lang.String mode)
|
| Uses of Node in org.dom4j.tree |
|---|
| Classes in org.dom4j.tree that implement Node | |
|---|---|
class |
org.dom4j.tree.AbstractAttribute
AbstractNamespace is an abstract base class for tree
implementors to use for implementation inheritence. |
class |
org.dom4j.tree.AbstractBranch
AbstractBranch is an abstract base class for tree implementors
to use for implementation inheritence. |
class |
org.dom4j.tree.AbstractElement
AbstractElement is an abstract base class for tree
implementors to use for implementation inheritence. |
class |
org.dom4j.tree.AbstractNode
AbstractNode is an abstract base class for tree implementors
to use for implementation inheritence. |
class |
org.dom4j.tree.BaseElement
BaseElement is a useful base class for implemementation
inheritence of an XML element. |
class |
org.dom4j.tree.DefaultAttribute
DefaultAttribute implements a doubly linked node which
supports the parent relationship and is mutable. |
class |
org.dom4j.tree.DefaultElement
DefaultElement is the default DOM4J default implementation of
an XML element. |
class |
org.dom4j.tree.FlyweightAttribute
FlyweightAttribute is a Flyweight pattern implementation of a
singly linked, read-only XML Attribute. |
| Uses of Node in org.dom4j.util |
|---|
| Classes in org.dom4j.util that implement Node | |
|---|---|
class |
IndexedElement
IndexedElement is an implementation of Element which
maintains an index of the attributes and elements it contains to optimise
lookups via name. |
class |
NonLazyElement
NonLazyElement is the default DOM4J default implementation of
an XML element. |
class |
UserDataAttribute
UserDataAttribute support the adornment of a user data object
on an Element or Attribute instance such that the methods
UserDataAttribute.setData(Object) will get and set the values of a user data object. |
class |
UserDataElement
UserDataElement support the adornment of a user data object on
an Element or Attribute instance such that the methods
UserDataElement.setData(Object) will get and set the values of a user data object. |
| Methods in org.dom4j.util with parameters of type Node | |
|---|---|
protected void |
IndexedElement.addNode(Node node)
|
int |
NodeComparator.compare(Node n1,
Node n2)
|
protected boolean |
IndexedElement.removeNode(Node node)
|
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


{% extends "base.html" %} {% block title %} {{ puzzle.spoiler_free_title }} / Answers {% endblock %} {% block main %}
You are not spoiled on this puzzle! Why are you trying to assign answers to it?
If you really want to, you can click back to it and spoil yourself.
{% endif %} {% endblock %} {% block extrajs %} {% endblock %}


Maintains a list of items. The idea is to stay as true as possible to the native Array interface, but to augment its usefulness by triggering events whenever the list is updated, as well as adding convenience functions for mutating the List in place.
The exported List constructor can be used as-is, in which case a generic List will be created. This is a quite common use case. Alternatively, a List "subclass" constructor can be created by calling List.withProperties(...)
. This second approach provides the possibility to add custom calculated properties to the list. See module:bff/list#withProperties for more details.
new (require("bff/list"))( [items])
Creates a new List, with an optional list or array of initial items.
Parameters:
| Name | Type | Argument | Description |
|---|---|---|---|
items |
Array | List |
<optional> |
Items that will be added to the List on creation. |
- Mixes In:
- Source:
Methods
-
<static> withProperties(schema)
-
Creates a new List constructor function, that will create List instances with the property schema
provided to this functionParameters:
Name Type Description schema
Object An object describing the properties that will be part of all new instances created by the returned constructor function. The property descriptions should be on the same format at the schema specified for module:bff/record.withProperties, with the only exception that setters are not allowed.
Returns:
New constructor function based on the provided schema.
- Type
- function
-
addEventListener(eventName)
-
Augmented version of bff/event-emitter#addEventListener that provides the option to listen to events emitted from any item in the List. To add a listener to an item event, prepend the event name with 'item:'. For instance, to listen for the 'change' event on all the list items (even ones added after the listener was created), add a listener for the 'item:change' event.
Parameters:
Name Type Description eventName
string Identifier string for the event.
-
clear()
-
Mutates the List by removing all items.
Fires:
Returns:
The List, now empty.
- Type
- List
-
concat(value)
-
Returns a new List comprised of the List on which it is called joined with the List(s), Array(s) and/or value(s) provided as arguments. Mirrors the behavior of Array.concat.
Parameters:
Name Type Argument Description value
any <repeatable>
A List, Array or value that will be concatenated with the original List. Lists and Arrays will be deconstructed and each item added to the new List.
Returns:
The new List.
- Type
- List
-
every(predicate [, thisArg])
-
Mirrors Array.every behavior.
Parameters:
Name Type Argument Description predicate
module:bff/list~predicateCallback Executed once per List item.
thisArg
any <optional>
Value to use as "this" when executing callback.
Returns:
true if all items passes the predicate test, false otherwise.
- Type
- boolean
-
filter(predicate)
-
Creates a new List with all items that pass the test implemented by the predicate function test. The original list is unchanged. Mirrors the behavior of Array.filter.
Parameters:
Name Type Description predicate
module:bff/list~predicateCallback Executed once per List item.
Returns:
The new List.
- Type
- List
-
filterMut(predicate [, thisArg])
-
Mutates the List by removing all items that does not pass the predicate function test.
Parameters:
Name Type Argument Description predicate
module:bff/list~predicateCallback Called once per List item to determine whether the item should be removed.
thisArg
any <optional>
Value to use as "this" when executing predicate callback.
Fires:
Returns:
The filtered List.
- Type
- List
-
find(predicate)
-
Returns the first item in the List that passes the predicate function test, or undefined if no item passes.
Parameters:
Name Type Description predicate
module:bff/list~predicateCallback Called once per List item to in order to find a matching item.
Returns:
The matching item, if any.
- Type
- any | undefined
-
findIndex(predicate)
-
Returns the index of the first item in the List that passes the predicate function test, or -1 if no item passes.
Parameters:
Name Type Description predicate
module:bff/list~predicateCallback Called once per List item to in order to find a matching item.
Returns:
The position of the matching item, or -1 if none matches.
- Type
- number
-
forEach(callback [, thisArg])
-
Executes the given function once per List item. Mirrors Array.forEach behavior.
Parameters:
Name Type Argument Description callback
module:bff/list~forEachCallback The function that will be called once per List item.
thisArg
any <optional>
Value to use as "this" when executing callback.
-
includes(item [, fromIndex])
-
Returns whether the provided item is part of the List.
Parameters:
Name Type Argument Description item
any fromIndex
number <optional>
The index to start the search at. If the index is greater than or equal to the List's length, -1 is returned, which means the List will not be searched. If the provided index value is a negative number, it is taken as the offset from the end of the List.
Returns:
True if the item is part of the List, false otherwise.
- Type
- boolean
-
indexOf(searchItem [, fromIndex])
-
Mirrors Array.indexOf behavior.
Parameters:
Name Type Argument Description searchItem
any The item to locate within the List.
fromIndex
number <optional>
The index to start the search at. If the index is greater than or equal to the List's length, -1 is returned, which means the List will not be searched. If the provided index value is a negative number, it is taken as the offset from the end of the List.
Returns:
The first index at which a given item can be found in the List, or -1 if it is not present.
- Type
- number
-
join( [separator])
-
Parameters:
Name Type Argument Description separator
string <optional>
Specifies a string to separate each item of the List. If omitted, the List items are separated with a comma. Mirrors Array.join behavior.
Returns:
The stringified List items, joined by the 'separator' string argument.
- Type
- string
-
lastIndexOf(searchItem [, fromIndex])
-
Parameters:
Name Type Argument Description searchItem
any The item to locate within the List.
fromIndex
number <optional>
The index at which to start searching backwards. Defaults to the List's length minus one, i.e. the whole List will be searched. If the index is greater than or equal to the length of the List, the whole List will be searched. If negative, it is taken as the offset from the end of the List. Mirrors Array.lastIndexOf behavior.
Returns:
The last index at which a given item can be found in the List, or -1 if it is not present.
- Type
- number
-
map(callback [, thisArg])
-
Creates a new List with the results of calling a provided callback function on every element in the List. Mirrors the behavior of Array.map.
Parameters:
Name Type Argument Description callback
module:bff/module~mapCallback Executed once per List item.
thisArg
any <optional>
Value to use as "this" when executing callback.
Returns:
The new List.
- Type
- List
-
mapMut(callback [, thisArg])
-
Replaces all items in the List with new items, generated by the callback function.
Parameters:
Name Type Argument Description callback
module:bff/module~mapCallback Executed once per List item to produce new items.
thisArg
any <optional>
Value to use as "this" when executing callback.
Fires:
Returns:
The List, with all items updated.
- Type
- List
-
pop()
-
Remove and return one item from the end of the List. Mirrors Array.pop behavior.
Fires:
Returns:
Removed item
- Type
- any
-
propertiesToJSON()
-
Returns a newly created Object containing the List's deep copied properties.
Returns:
- Type
- Object
-
push(item)
-
Add one or more items to the end of the List. Mirrors Array.push behavior.
Parameters:
Name Type Argument Description item
any <repeatable>
Each item argument will be pushed onto the List.
Fires:
Returns:
Updated List length
- Type
- number
-
pushAll(items)
-
Mutates the List by adding the items comprising the provided List or Array to the end of the List.
Parameters:
Name Type Description items
module:bff/list | Array The items that will be appended to the List.
Fires:
Returns:
The List, with new items appended.
- Type
- List
-
reduce(callback, initialValue)
-
Applies a function against an accumulator and each value of the List (from left-to-right) to reduce it to a single value. Mirrors Array.reduce behavior.
Parameters:
Name Type Description callback
module:bff/list~reduceCallback The function that will be called once per List item.
initialValue
any Value to use as the first argument to the first call of the callback.
Returns:
Aggregated value
- Type
- any
-
reduceRight(callback, initialValue)
-
Applies a function against an accumulator and each value of the List (from right-to-left) to reduce it to a single value. Mirrors Array.reduceRight behavior.
Parameters:
Name Type Description callback
module:bff/list~reduceCallback The function that will be called once per List item.
initialValue
any Value to use as the first argument to the first call of the callback.
Returns:
Aggregated value
- Type
- any
-
remove(item)
-
Mutates the List by removing all occurances of the provided item.
Parameters:
Name Type Description item
any The item to remove from the list.
Fires:
Returns:
The List, without any occurances of 'item'.
- Type
- List
-
removeEventListener(eventName)
-
Augmented version of bff/event-emitter#removeEventListener that provides functionality for removing "item" event listeners, e.g. for stop listening to events like "items:change".
Parameters:
Name Type Description eventName
string Identifier string for the event.
-
reverse()
-
Reverses the List in place. Mirros the behavior of Array.reverse. No events are emitted by this operation.
-
shift()
-
Remove and return one item from the beginning of the List. Mirrors Array.shift behavior.
Fires:
Returns:
Removed item
- Type
- any
-
slice( [begin] [, end])
-
Creates a new List from the range of current items specified by the begin and end arguments. Mirrors the behavior of Array.slice.
Parameters:
Name Type Argument Description begin
number <optional>
Index that specifies the beginning of the range. Inclusive. A negative index will
be relative to the end of the List instead of the beginning.end
number <optional>
Index that specifies the end of the range. Exclusive. A negative index will
be relative to the end of the List instead of the beginning.Returns:
The new List.
- Type
- List
-
sliceMut( [begin] [, end])
-
Mutates the List by removing all elements outside of range specified by the begin and end arguments.
Parameters:
Name Type Argument Description begin
number <optional>
Index that specifies the beginning of the range. Inclusive. A negative index will be relative to the end of the List instead of the beginning.
end
number <optional>
Index that specifies the end of the range. Exclusive. A negative index will be relative to the end of the List instead of the beginning.
Fires:
Returns:
The List, sans the items outside of the specified range.
- Type
- List
-
some(predicate [, thisArg])
-
Mirrors Array.some behavior.
Parameters:
Name Type Argument Description predicate
module:bff/list~predicateCallback Executed once per List item.
thisArg
any <optional>
Value to use as "this" when executing callback.
Returns:
true if at least one item passes the predicate test, false otherwise.
- Type
- boolean
-
sort( [comparator])
-
Sorts the items of the List in place. The sort is not necessarily stable. The default sort order is according to string Unicode code points, unless a custom comparator finction is provided. Mirrors the behavior of Array.sort. No events are emitted by this operation.
Parameters:
Name Type Argument Description comparator
module:bff/list~compareFunction <optional>
A function that specifies the ordering of two arbitrary List items. Called multiple times in order to produce a total ordering of the items.
Returns:
The sorted list.
- Type
- List
-
splice(start, nItemsToRemove [, itemToAdd])
-
Changes the content of the List by removing existing items and/or adding new items. Mirrors Array.splice behavior.
Parameters:
Name Type Argument Description start
number Index at which to start changing the array. If greater than the length of the array, actual starting index will be set to the length of the array. If negative, will begin that many items from the end.
nItemsToRemove
number An integer indicating the number of old array items to remove. If nItemsToRemove is greater than the number of items left in the array starting at start, then all of the items through the end of the array will be deleted.
itemToAdd
any <optional>
<repeatable>
Item that will be added to the array, starting at the index specified in the first argument.
Fires:
- module:bff/list#change:length
- module:bff/list#item:added
- module:bff/list#item:replaced
- module:bff/list#item:removed
Returns:
Array of removed items
- Type
- Array.<any>
-
toArray()
-
Returns an newly created Array, containing all the items of the List. List properties are not copied to the Array object. The items are copied shallowly.
Returns:
- Type
- Array
-
toJSON()
-
Returns a newly created Array representation of the List, containing deep copies of all the List's items, but not its properties.
Returns:
- Type
- Array
-
toString()
-
Returns:
A human readable string representation of the List.
- Type
- string
-
unshift(item)
-
Add one or more items to the beginning of the List. Mirrors Array.unshift behavior.
Parameters:
Name Type Argument Description item
any <repeatable>
Each item argument will be pushed onto the List.
Fires:
Returns:
Updated List length
- Type
- Number
Type Definitions
-
compareFunction(itemA, itemB)
-
Compares itemA and itemB arguments according to some sorting criterion. Should return -1 if itemA comes before itemB, 0 if itemA is equal to itemB, 1 if itemB comes before itemA.
Parameters:
Name Type Description itemA
any A list item.
itemB
any Another list item.
Returns:
.
- Type
- number
-
forEachCallback(item, index, list)
-
Parameters:
Name Type Description item
any Current List item.
index
number Item position in List.
list
module:bff/list List being iterated over.
-
mapCallback(item, index, list)
-
Parameters:
Name Type Description item
any Current List item.
index
number Item position in List.
list
module:bff/list List being iterated over.
Returns:
Transformed object.
- Type
- any
-
predicateCallback(item, index, list)
-
Parameters:
Name Type Description item
any Current List item.
index
number Item position in List.
list
module:bff/list List being iterated over.
Returns:
true if the item passes the test, false otherwise
- Type
- boolean
-
reduceCallback(previousItem, item, index, list)
-
Parameters:
Name Type Description previousItem
any The value previously returned in the last invocation of the callback, or initialValue, if supplied. Usually an aggregate of previous items.
item
any Current List item being processed.
index
number Item position in List.
list
module:bff/list List being iterated over.
Returns:
The aggregated value.
- Type
- any
Events
-
change:length
-
Parameters:
Name Type Description newLength
number The current length of the List.
oldLength
number The previous length of the List.
list
module:bff/list The List whose length has changed.
-
item:added
-
Parameters:
Name Type Description item
any The item that was added to the List.
index
number The position withing the List where the item was added.
list
module:bff/list The List to which the item was added.
-
item:removed
-
Parameters:
Name Type Description item
any The item that was removed from the List.
index
number The position withing the List where the item was removed.
list
module:bff/list The List from which the item was removed.
-
item:replaced
-
Parameters:
Name Type Description newItem
any The item that was added to the List.
oldItem
any The item that was removed from the List.
index
number The position withing the List where the item was replaced.
list
module:bff/list The List in which the item was replaced.


Contents of the Haskell Platform
The contents of the Haskell Platform are specified as this Cabal file.
Compiler
Core Libraries, Provided with GHC
Additional Platform Libraries
Programs and Tools


TNGHT – “First Body”
by James RettigNext week, TNGHT are releasing their first EP in seven years, II. The production duo of Hudson Mohawke and Lunice — who made our recently published Best Songs Of The 2010s list — have shared two tracks from it so far, “Serpent” and “Dollaz,” and today they’re back with another one, “First Body,” a great bit of digitized bubbly mayhem. “it sounds like whale song it sounds like the beatles do you like the beatles SMASH this url immediately………………….,” TNGHT said in a tweet. True! Listen below.
II is out 11/12 via Warp/Lucky Me.


public class MyFirst {
public static void main(String[] args) {
System.out.println("Hello, World");
}
}
Boy name = Johnny
Girl name = Rae
// Fall in love river.
The boy love the girl;
// They love each other.
The girl loved the boy;
// AS time goes on.
The boy can not be separated the girl;
// At the same time.
The girl can not be separated the boy;
The boy very happy;
The girl is also very happy;
// Whether it is right now
// Still in the distant future.
The boy has but one dream;
// The boy wants the girl could well have been happy.
I want to say:
Rururu, I love you forever;
public static void main(String[] args) {
System.out.println("Hello, World");
}
}
Boy name = Johnny
Girl name = Rae
// Fall in love river.
The boy love the girl;
// They love each other.
The girl loved the boy;
// AS time goes on.
The boy can not be separated the girl;
// At the same time.
The girl can not be separated the boy;
The boy very happy;
The girl is also very happy;
// Whether it is right now
// Still in the distant future.
The boy has but one dream;
// The boy wants the girl could well have been happy.
I want to say:
Rururu, I love you forever;
亲爱的，这是我们相爱在一起的时光。
love you ru me, always care about you ~.
--johnny


{% extends 'base.html' %} {% load staticfiles %} {% block content%} {% if group == "regular" %}
WORKOUT PLAN
WEIGHT TRACKER
BUDDY MATCH
SCREENINGS
CREATE SCREENING
ACCESS SCREENINGS
MANAGE WORKOUTS
DASHBOARD
ACCOUNTS MANAGEMENT


At the root of the source directory there is a configure.js
file that you can tweak as you see fit.
module.exports =
{
AUTHOR_s: 'octoxalis', //: github name
EMAIL_s<EMAIL_ADDRESS>//: github e-mail
ID_s: '11tyframe', //: github repository
NAME_s: '11ty Frame', //: site name
URL_s: `https://11tyframe.netlify.com/`, //: CDN deployer
LOCAL_s: 'http://<IP_ADDRESS>:5500/', //: local address and port for development
COLLECTION_s: 'post', //: Eleventy tag for posts collection
LANGUAGE_s: 'en', //: Site language
description_o: //: descriptions for SEO
{
DESCRIPT_s: '11ty Frame blog',
GLOBAL_s: 'Eleventy,static site generator',
},
HUE_P_n: 0, //: theme primary color in range [0...359]
HUE_L_n: 50, //: theme link color offset from primary color
HUE_S_n: -50, //: theme secondary color offset from primary color
HUE_I_n: 20, //: theme important color offset from primary color
HUE_D_n: -20, //: theme decorative color offset from primary color
LUM_MODE_n: 1, //: luminosity mode: 1 (light) || -1 (dark)
LUM_CONTRAST_n: 40, //: luminosity contrast in range [30...49] (30 is less contrast than 49)
//: see https://www.w3.org/TR/WCAG20/ §1.4.1 compliance
}
The properties of this configuration file are self-documenting but some of them need a few explanations, notably those properties whose names begin by HUE and LUM.
All 11ty Frame colors are defined by CSS custom properties and the HUE properties define the variations of these colors:
These properties values are numbers, positive and negative, specifying the variation around the primary color (HUE_P_n
) value that you declare.
For instance, if you set:
HUE_P_n: 153,
HUE_L_n: 50,
this declaration will yield a link color of 203
for anchors
153 + 50 = 203
. Similarly, the secondary color (HUE_S_n
) will be 103
153 - 50 = 103
but you could have well define that property as:
HUE_S_n: -30,
to obtain 123
as secondary color hue
153 - 30 = 123
. Nothing requires you to have simetrical values for your color variations, you only have to experiment some combinations to get what you consider the optimal result.
All variations once defined, any visitor of your site will be able to change the base color hue with a single click over the page header, selecting one of the 360 different hues available in the HSL color system used by 11ty Frame. Nevertheless, if you want to prevent the possiblity to change this base color hue, you can do it by setting the HUE_SET_n
to 0
in the configure.js
file.


${athlete.firstName} ${athlete.lastName}
${athlete.Workouts.map(workout => `
${workout.exercise}
Sets: ${workout.sets} Reps: ${workout.reps}
Weight: ${workout.weight}
Delete
Edit
`).join('')}
${athlete.Workouts.map(workout => `
Edit Workout
Exercise Name
Sets
Reps
Weight
Submit
`).join('')}
Add Workout
Exercise Name
Sets
Reps
Weight
Submit


Link to ITacad Web site
new line
This text is emphasized.
new line
This one is more emphasized.
Heading 1
Sub heading 2
Sub heading 3
This is my first paragraph;
This is my second paragraph
This is a div
- Apple
- Orange
- Grapefruit
- HTML
- A markup language
- CSS
- Language used to


Any Place,
Any Time.
Keep track of all your anytimers.

Enable JavaScript for the full experience.


| 1 |
Pandejpong_2012 |
Appropriate time-interval application of alcohol hand gel on reducing influenza-like illness among preschool children: A randomized, controlled trial |
Pandejpong, Denla; Danchaivijitr, Somwang; Vanprapa, Nirun; Pandejpong, Temyos; Cook, Earl Francis |
2012 |
2012-08-31 |
PMC |
N |
PMC7115319 |
22264742.0 |
10.1016/j.ajic.2011.08.020 |
s949v118 |
0.622819 |
Park_2018, Torner_2015, Goka_2014 |
|
| 2 |
Pang_2015 |
Current knowledge, attitude and behaviour of hand and food hygiene in a developed residential community of Singapore: a cross-sectional survey |
Pang, Junxiong; Chua, Shao Wei Jonathan Lumen; Hsu, Liyang |
2015 |
2015-06-21 |
COMM-USE |
N |
PMC4475322 |
26093582.0 |
10.1186/s12889-015-1910-3 |
4i6km0oa |
0.604436 |
Lim_D_2017, Rossi_2020, Muniz-Rodriguez_2020, Torner_2015 |
|
| 3 |
Lim_D_2017 |
Psychosocial determinants of influenza vaccination intention: A cross-sectional study on inpatient nurses in Singapore |
Lim, Dwee Wee; Lee, Lay Tin; Kyaw, Win Mar; Chow, Angela |
2017 |
2017-10-01 |
PMC |
N |
PMC7132738 |
28449916.0 |
10.1016/j.ajic.2017.03.017 |
zmna5ovl |
0.561618 |
Rossi_2020, Muniz-Rodriguez_2020, Angraal_2018, Torner_2015 |
|
| 4 |
Yang_2011 |
Mask-wearing and respiratory infection in healthcare workers in Beijing, China |
Yang, Peng; Seale, Holly; Raina MacIntyre, C.; Zhang, Haiyan; Zhang, Zhen; Zhang, Yi; Wang, Xiaoli; Li, Xinyu; Pang, Xinghuo; Wang, Quanyi |
2011 |
2011-04-30 |
PMC |
N |
PMC7129448 |
21503394.0 |
10.1016/s1413-8670(11)70153-2 |
5043wcdt |
0.544150 |
Rossi_2020, Lim_D_2017, Muniz-Rodriguez_2020 |
|
| 5 |
Chen_2010 |
Risk Factors for Pandemic (H1N1) 2009 Virus Seroconversion among Hospital Staff, Singapore |
Chen, Mark I.C.; Lee, Vernon J.M.; Barr, Ian; Lin, Cui; Goh, Rachelle; Lee, Caroline; Singh, Baldev; Tan, Jessie; Lim, Wei-Yen; Cook, Alex R.; Ang, Brenda; Chow, Angela; Tan, Boon Huan; Loh, Jimmy; Shaw, Robert; Chia, Kee Seng; Lin, Raymond T.P.; Leo, Yee Sin |
2010 |
2010-10-23 |
PMC |
N |
PMC3294397 |
20875280.0 |
10.3201/eid1610.100516 |
dq2219ro |
0.524590 |
Rossi_2020, Gao_Y_2020, Lim_D_2017 |
|
| 6 |
Luo_Y_2010 |
Factors impacting compliance with standard precautions in nursing, China |
Luo, Yang; He, Guo-Ping; Zhou, Jijan-Wei; Luo, Ying |
2010 |
2010-12-31 |
PMC |
N |
PMC7110552 |
21071254.0 |
10.1016/j.ijid.2009.03.037 |
vu2cre8k |
0.516586 |
Rossi_2020, Muniz-Rodriguez_2020, Lim_D_2017, Gao_Y_2020 |
|
| 7 |
McCaw_2012 |
Household transmission of respiratory viruses – assessment of viral, individual and household characteristics in a population study of healthy Australian adults |
McCaw, James M; Howard, Peter F; Richmond, Peter C; Nissen, Michael; Sloots, Theo; Lambert, Stephen B; Lai, Michael; Greenberg, Michael; Nolan, Terry; McVernon, Jodie |
2012 |
2012-12-11 |
COMM-USE |
N |
PMC3538067 |
23231698.0 |
10.1186/1471-2334-12-345 |
z7ygy25e |
0.508502 |
Dinh_2006 |
|
| 8 |
Torner_2015 |
Effectiveness of non-pharmaceutical measures in preventing pediatric influenza: a case–control study |
Torner, Núria; Soldevila, Núria; Garcia, Juan Jose; Launes, Cristian; Godoy, Pere; Castilla, Jesús; Domínguez, Angela |
2015 |
2015-06-09 |
COMM-USE |
N |
PMC4459072 |
26055522.0 |
10.1186/s12889-015-1890-3 |
vzqrxj2w |
0.507613 |
Rossi_2020, Muniz-Rodriguez_2020, Al_Mawly_2015 |
|
| 9 |
Pang_2015 |
Risk factors for febrile respiratory illness and mono-viral infections in a semi-closed military environment: a case-control study |
Pang, Junxiong; Jin, Jing; Loh, Jin Phang; Tan, Boon Huan; Koh, Wee Hong Victor; Ng, Sock Hoon; Ho, Zheng Jie Marc; Gao, Qiuhan; Cook, Alex R; Hsu, Li Yang; Lee, Vernon J; Chen, Mark I Cheng |
2015 |
2015-07-25 |
COMM-USE |
N |
PMC4514976 |
26208494.0 |
10.1186/s12879-015-1024-7 |
mbwgi56x |
0.503316 |
Rossi_2020, Muniz-Rodriguez_2020, Torner_2015, Lim_D_2017, Angraal_2018 |
|
| 10 |
Wu_S_2018 |
Willingness to accept a future influenza A(H7N9) vaccine in Beijing, China |
Wu, Shuangsheng; Su, Jianting; Yang, Peng; Zhang, Haiyan; Li, Hongjun; Chu, Yanhui; Hua, Weiyu; Li, Chao; Tang, Yaqing; Wang, Quanyi |
2018 |
2018-01-25 |
PMC |
N |
|
29246476.0 |
10.1016/j.vaccine.2017.12.008 |
rydgncys |
0.468459 |
Rossi_2020, Muniz-Rodriguez_2020, Gao_Y_2020, Lim_D_2017 |
|
| 11 |
Shih_2012 |
Impacts of rapid flu clinic services at an emergency department during the pandemic flu season |
Shih, Hsin-I.; Ho, Tzong-Shiann; Chang, Chia-Ming; Hsu, Hsiang-Chin; Wang, Shih-Min; Liu, Ching-Chuan; Ko, Wen-Chien; Wu, Yi-Hui; Chiu, Yen-Ling; Sheu, Bor-Shyang; Chi, Chih-Hsien |
2012 |
2012-03-31 |
PMC |
N |
PMC7115284 |
21775019.0 |
10.1016/j.ajic.2011.03.006 |
aqif7q3n |
0.455847 |
Rossi_2020, Muniz-Rodriguez_2020, Gao_Y_2020 |
|
| 12 |
Gasparini_2013 |
Effectiveness of adjuvanted seasonal influenza vaccines (Inflexal V(®) and Fluad(®)) in preventing hospitalization for influenza and pneumonia in the elderly: A matched case-control study |
Gasparini, Roberto; Amicizia, Daniela; Lai, Piero Luigi; Rossi, Stefania; Panatto, Donatella |
2013 |
2013-01-01 |
NONCOMM |
N |
PMC3667930 |
23143775.0 |
10.4161/hv.22231 |
epyc37sz |
0.439118 |
|
|
| 13 |
MACINTYRE_2013 |
Quantifying the risk of respiratory infection in healthcare workers performing high-risk procedures |
MACINTYRE, C. R.; SEALE, H.; YANG, P.; ZHANG, Y.; SHI, W.; ALMATROUDI, A.; MOA, A.; WANG, X.; LI, X.; PANG, X.; WANG, Q. |
2013 |
2013-12-05 |
COMM-USE |
N |
PMC4102100 |
24308554.0 |
10.1017/s095026881300304x |
oi3ezlsl |
0.373740 |
|
Kwon_2017 |
| 14 |
Dinh_2006 |
Risk Factors for Human Infection with Avian Influenza A H5N1, Vietnam, 2004 |
Dinh, Pham Ngoc; Long, Hoang Thuy; Tien, Nguyen Thi Kim; Hien, Nguyen Tran; Mai, Le Thi Quynh; Phong, Le Hong; Van Tuan, Le; Van Tan, Hoang; Nguyen, Nguyen Binh; Van Tu, Phan; Phuong, Nguyen Thi Minh |
2006 |
2006-12-23 |
PMC |
N |
PMC3291373 |
17326934.0 |
10.3201/eid1212.060829 |
hp1dt3zc |
0.359499 |
Rossi_2020, Torner_2015, Al_Mawly_2015 |
|
| 15 |
Lam_T_2008 |
Comments to the predecessor of human SARS coronavirus in 2003–2004 epidemic |
Lam, Tommy Tsan-Yuk; Hon, Chung-Chau; Lam, Pui-Yi; Yip, Chi-Wai; Zeng, Fanya; Leung, Frederick Chi-Ching |
2008 |
2008-01-25 |
PMC |
N |
PMC7117273 |
17884305.0 |
10.1016/j.vetmic.2007.08.014 |
xa8b1nuo |
0.329573 |
|
|


Home
About
Sign Up
Upcoming Games
Make a Game
Baller
Connections
Find local ballers
Find Out More
Baller Connections is the best way to find pickup basketball games nearby.
Write more stuff about the site.
Sign Up
Name
Phone Number
Zip Code
Zip Code Range
When are you available?
Sun
Mon
Tue
Wed
Thur
Fri
Sat
What level of play are you looking for?
Fun
Intense
Hardcore
Submit
Upcoming Games
No up coming games planned.
{{ game.address }}
Tipoff at {{ game.tipOff }}


This is Wilson. He may have 3 legs, but will definitely be your favorite neighbor. He is also the dogs world champion. Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
Rudy the bat is disease free since 2014. Great personality, even greater looks. He sleeps by day, eats fruit upside down by night.
Chad...chad here, is not the best. Likes axe body spray, and creeping people out. Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.
This is Jesus, the chillest, illest, reptiliast lizard around. Not only is he chill, but he doesn't need much attention. He likes chillin in his log, basking in the sun.


LowBid Pizza
Home
(current)
Cheap Delicious Pizza!
Find the best pizza at the lowest cost!
Cheap Delicious Pizza!
Find the best pizza at the lowest cost!
Cheap Delicious Pizza!
Find the best pizza at the lowest cost!
Previous
Next
Welcome! Please Sign In!
Email address:
Password:
Login


1974 – Threshold Test Ban Treaty (TTBT)
The Threshold Test Ban Treaty limited underground nuclear tests to 150 kilotons (equivalent to 150,000 tons of TNT). The Soviet Union and United States both signed the TTBT in 1974, however neither party agreed to observe the limits proposed by the treaty until 1976, and the treaty did not enter into force until 1990.


Feed-Forward
Feed-Forward (demo)
Recurrent Neural Network
Recurrent Neural Network (demo)
Neuron
Name
Layer
Synapse
From
To
Strength


A Review of Hnefatafl by Pub Games of England
Hneftafl…the vikings’ board game by Pub Games of England is an interesting vintage set. There are no dates on the box. If I had to guess, I would say it was produced some time in the 1980’s. I’ve seen the set for sale online with a slightly different box label stating the company was located in Sussex, England.
This set is simple and beautiful. The rustic wooden board is compact measuring at 5.5 inches squared. It is a 7x7 playing area with holes instead of squares. The playing pieces are wooden pegs that fit into the holes. There are 12 light wood attackers, 6 dark wood defenders and 1 king. If you’re thinking this seems unusual for a brandub sized board, you’re right! There are 50% more pieces than your classic brandub game. Also unusual is the setup of the game (shown in the picture).
The rules will feel very normal for any fan of tafl games.
- Attackers move first.
- Only the king may enter the center square.
- All pieces move like a rook in chess.
- Pieces captured by sandwiching.
- The defenders win by the king escaping to any edge.
- The attackers win by capturing the king on 4 sides.
- The king can be captured on 3 sides if it sitting on a space orthogonal to the center square.
This is a great little set that is sometimes hard to find. I do feel there are probably too many pieces for the board size (though it’s not as bad as the game of ard ri). The pegs and compact form factor makes it perfect to play at a coffee shop or travelling. I wish I knew more about the publishers. The fun part for me when finding these old vintage sets is not only the variation in rules but learning a bit about the publishers that produced them. If you happen to know more, feel free to DM or tweet to @richfamilygames.


Majestic Cinemas:
Select a Movie:
Harry Potter and the Order of the Phoenix (Throwback!)
Parasite
Trolls: World Tour
Mulan
How To Not Suck at Programming: A Horror Story
Select a Showtime:
10 am
12:30 pm
1:30 pm
6 pm
9:30 pm
Enter number of Matinee Tickets:
Enter number of Senior Tickets:
Enter number of Kids (under 12) Tickets:
Add to Cart
Your Shopping Cart:
Mattinee: x
Senior: x
Kids: x


A collection of scales based on the harmonic series, with a touch of xen.
This pattern has become a compilation. It began with just the two related bizarro takes on the harmonic series I developed together back in 2016: the matharmonic series and the edharmonic series. But when it came time to implement some of the other musical scales I've described that are also based on the harmonic series, I balked at the idea of introducing a separate pattern as their home, and/or I was tempted by the challenge to achieve them using the same underlying mechanisms through which I was bringing the matharmonic and edharmonic to life. Well, I shouldn't write the act off as a mere indulgence; indeed I have many good reasons for my goal to standardize my recent musical work under a single system.
So in the end, this pattern contains the power to take the form of my matharmonic and edharmonic series, as well as the third tritave of the odd harmonics, and my set of "particular" series, plus some others. To make this happen, Xenharmonic series has by far the most complicated specs of any of my patterns, with a whopping thirteen interactive controls. Please check out the presets — those are my original patterns — but take a look at which of the controls they care about, and explore fiddling with them and creating new Frankenstein scales from all the harmonic series related ideas at play here.
I suppose I'll more or less copy and paste the material from my original blog posts on these families of patterns, to save time. Don't expect my writing voice to be the same in each segment though...
I've come up a couple variations on the harmonic series.
Let's go right ahead to my final results. This is for the benefit of harder core math folks who may not be into slogging through my discovery process. If you are not so mathy, I suggest you skip to the end of this section where the sound samples live, and then slog through my discovery process with me to gradually piece these math expressions together.
So if the traditional harmonic series is defined as beginning with a base frequency a and stepping up the integer multiples of that frequency, then we can write the sequence of frequencies {Sn} where n ≥ 1 and Sn =
which admittedly looks a bit over the top expressed as a partial sum, but it helps for comparison with the first variation I'm proposing which actually uses the k in an otherwise identical Sn (though for aesthetic reasons which we'll get to later the actual final version of this will be a tad different):
We also propose the variations where Sn =
and b > 1 (we in particular will look at b = 2).
And here's what these three series sound like, if you wanna spoil the surprise by experiencing them without further dramatic buildup.
Please turn back now if these matters are of no interest to you either mathically or musically.
This all began with a simple enough question: what is the relationship between the musical harmonic series and the mathematical harmonic series?
Without having pried the issue apart before, I'd been cruising through life comfortable with the assumption that the former was an application of the latter to the musical domain: the terms of the mathematical harmonic series being 1, ½, ⅓, ¼, ... and the musical harmonic series the succession of pitches you hear plucking strings of those lengths1.
1 Plus I also knew that they both had something to do with logarithms (more on this later).
But there's more to the mathematical harmonic series than that: it is not merely the sequence of its terms 1, ½, ⅓, ¼, ... but the summation of those terms: 1 + ½ + ⅓ + ¼ + ... In the previous ¶ I was simulating the ignorance of my youth by glossing over this fact.
In math, you see, a distinction is made between a series and a sequence. A sequence is an ordered collection of objects (terms); optionally it can include repeated terms and/or be infinite in length. A series, on the other hand, is the sum total of the terms of such a sequence (in particular if it is one of the infinite kind).
So the mathematical harmonic series qualifies as a series in math-speak (as we would hope it would). But the musical harmonic series? Not so much. It is no singular object, the expression of the sum of some infinite mathematical sequence. It is, rather, one such sequence of objects. Being the succession of multiples of a base sound wave frequency which increase by 1 each time — 1x, 2x, 3x, 4x, ...2 — we can see that it has a definite order, and it will go on infinitely, and while it does not happen to contain any copies of any of its terms that's perfectly fine.
2 This being the effect of strings getting subdivided into lengths of 1, ½, ⅓, ¼, ...; if you took the terms of the mathematical harmonic series directly as your multiples what you'd end up with is what we call the subharmonic series.
To be clear: I'm not at all proposing an effort to rally the musical community around a renaming of one of the fundamental building blocks of music. Outside of mathematical settings, we can get away with "series" as the descriptor of the musical harmonic series. Since the general sense of series refers to a number of similar things coming one after another. Which, of course, the musical harmonic series is.
And I couldn't really get away with conforming the musical harmonic series to math-speak even if I wanted to, because not only was I wrong about the musical harmonic series being an application of a math idea to music, it turns out I was extra wrong i.e. that it's the other way around3. When the Divine Brotherhood of Pythagoras came up with the original (musical) harmonic series, infinity was not yet well understood, and mathematical series hadn't been invented/discovered. Over a millennia later when mathematicians finally conceived of their series — the sum of the infinite sequence of the reciprocals of the natural numbers: 1 + ½ + ⅓ + ¼ + ... + 1/k as k approaches infinity, or in Big Sigma notation:
3 That is to say that if anything we should gripe about the mathematical harmonic series failing to conform to the music-speak, except that a) there is no technical meaning of series in music to worry about, and b) I have no idea as to the historical and etymological (dis)continuity between our modern English collision on meanings of "series" and these mathematicians' naming in the first place.
— they could have named it anything, but I suppose why not name it "harmonic" after something related to it and for which both it and its name are beautiful4?
4 The name might have been intermediated by the harmonic mean. I am not even beginning to attempt to write math history here. I'm intimidated by David Foster Wallace's Everything and More: A Compact History of Infinity and criticisms theroef (though I have definitely cribbed its style here).
Now that I had nailed down the relationship between the mathematical and musical harmonic series, and learned that I had been wrong about the musical harmonic series being the mathematical harmonic series applied to music, I began to wonder: in what way(s) could I apply the mathematical harmonic series to music? Bring this puppy back around!
So there's another term in math called a partial sum. It's related to the math concept of a series. If the series is defined as the sum of "all" of the terms of an infinite sequence, then a partial sum is defined as the sum of some finite number of them.
So the first partial sum of the harmonic series, written S1, is trivially 1.
S2 is 3/2, because
1/1 + 1/2 =
2/2 + 1/2 =
3/2.
And S3 is 11/6, because
1/1 + 1/2 + 1/3 =
6/6 + 3/6 + 2/6 =
11/6.
And so on. So the sequence of partial sums1 of the mathematical harmonic series is
1/1,
3/2,
11/6,
25/12,
137/60,
49/20,
363/140,
...
1 As far as I've found, we have no special term for a sequence of partial sums.
So if you thought before that there was no practical difference between the math concept of series which involves summation (since who cares what the sum total of all these terms are, isn't it just ∞?) and the general usage of series, that I was merely splitting hairs over whether we connected terms with commas or plus signs, now you see where my interest lay. Already things are looking mighty interesting, at least if you're into microtonal/xenharmonic/alt-tuning stuff like I am.
Remember that the musical harmonic series is a sequence of pitches starting at some base frequency and moving up increasing multiples of it, 1x, 2x, 3x, 4x, ... Well, we can deploy this new sequence in much the same way.
Suppose we start with a base frequency of 220 Hz. The harmonic series on 220 Hz would go 220 Hz, 440 Hz, 660 Hz, 880 Hz, ... But this experimental series of ours goes differently: 220 Hz, 330 Hz, 403.3 Hz, 458.3 Hz, ...
Except that's there's a little fudging I'd like to do, and this isn't pretty, so I'll get it out of the way right now, and you can probably ignore this bit if you're in a hurry. You'll notice that the first steps of the harmonic series proportionally are 2x and 3/2x. We have a 3/2x move our new series, too, but it's its first step. I'd like those to align. Plus, you'll notice that we never actually get to use the 1which is the first term of our new series as an interval. So I think it's fair to say for our new series that we'll start at 0, then + 1, then + ½, etc. Except that we can't use 0 as a multiplier on frequency2, so we instead have to make our expression for our frequencies a little more complicated: it'll be a at n = 1, and for all further a:
2 0 Hz don't exist.
That way our experimental series will go 220 Hz, 440 Hz, 660 Hz, 806.6 Hz, 916.6 Hz, ... much closer to the traditional harmonic series. And this is what accounts for that extraction of an n as an a back in the intro. Ugh, sorry about that. Promise it's worth it in the sound.
Here's what the harmonic series on 220 Hz sounds like, with the base frequency droning underneath for comparison:
And here's what our new series sounds like:
What is this beast? I like it. It sounds interesting. I want to know more. Since it's an application of the mathematical harmonic series in a manner evocative of the musical harmonic series, maybe I'll call it the "matharmonic series"3.
3 I also considered "metaharmonic" and "epiharmonic" for their self-referentiality/uponicity, as this series involves taking one sense of the harmonic series and applying it to another, but something just didn't quite feel self-referential/uponicious enough.
One of the first things I note is that after not too long the matharmonic series starts to rise in pitch much more slowly than the harmonic series, and it even begins to sound like it might stop rising altogether at some point.
It'd be too easy to conclude this was completely explained by how its rate of rise decreases over time. Too easy as in wrong. Since as you probably noticed, the harmonic series also seems to be slowing down, even though we know its rate of rise remains constant.
Depending on how familiar you are with the harmonic series, you may or may not be surprised by this phenomenon. Its explanation lies in human pitch perception, which in math-speak we'd say is logarithmic.
We'll define logarithms later, but for now it should suffice to say that we hear relationships between pitches through ratios not differences. So while the difference between each pair of adjacent terms in the musical harmonic series remains constant, sure, look at their ratios as you go farther up: 2:1, 3:2, 4:3, 5:4, 6:5, ...1
1 These are called "superparticular ratios". Which I mention mostly just 'cuz it's such a cool name.
If this doesn't quite seal the deal for you, putting it in decimal form may: 2, 1.5, 1.3, 1.25, 1.2, ... The ratios are getting smaller. Meaning that while we're actually continuing to move by the same absolute amounts of frequency, we're perceiving less of a relative change in pitch each time.
Frequency tells what a sound wave actually is; pitch tells how we hear it.
A traditional graph is fine for frequency, but a better way to visualize pitch is to use a graph with a logarithmic scale (again, deferring definition). If we space things vertically by ratios (but importantly keep spacing things horizontally by difference, which traditional spacing we call linear), we can now see what we've been hearing2:
2 The units here, cents, are a common way of measuring logarithmic pitch. Don't worry about it for now.
And here we can also see that the matharmonic series is doubly curved-off. So we could say that the rising of the traditional harmonic series is fighting only against the diminishing returns of perceptual significance in upwards frequency motion, while the matharmonic series contends with both that as well as an actual decreasing in its rate of upward frequency motion.
On the pitch chart, the harmonic series looks curved. And I noticed that on the frequency chart — where the harmonic series looks straight — the matharmonic series looks curved in a similar way. So now I began to wonder: just what was the relationship between these two curves?
I already knew about logarithmic pitch perception. And I also already knew that the mathematical harmonic series had something to do with logarithms1. But if you recall, before I started picking all this apart I thought that the musical and mathematical harmonic series were essentially the same thing, so in my head this was all just fuzzily conflated; whatever logarithmic aspects each one exuded I assumed were nothing but different manifestations of a shared fundamental element.
1 Which I hinted at in a footnote from towards the beginning of the very first section. Hey, we're finally to the foreshadowed moment!
Now that I had come to the realization that the relationship between the musical and mathematical harmonic series was merely inspirational (not identical), though, I knew I couldn't take anything for granted anymore. "Something to do with logarithms" was no longer good enough.
So, like my grandfather always said to do, I reviewed the text.
"Let's review the text."
What I found was that the partial sums of the mathematical harmonic series roughly approximates the natural logarithm2. That is, the logarithm that gets its own cool notation ln, the base e logarithm, where e is one of those transcendental mathematical constants, in fact one of the most famousest ones ever, ≈ 2.71828, the mathematical essence of growth. So the curve that the matharmonic series was exhibiting in frequency space was then indeed a logarithmic curve: the natural kind.
And what of the harmonic series, in pitch space? Well that one I knew was a base 2 logarithm, as I had chosen the ratio 2:1 to space things vertically, because that is the most specialest ratio in pitch perception, the one of pitch class equivalence: it is the one which — for whatever human psychoacoustic reasons — gives us what we hear as a higher or lower version of the same note, and thus we even go so far as to name them as different numbers of the same letter e.g. A3, A4, A5.
For the record, 2 ≠ 2.71828.
2 It’s kind of amusing how the musical harmonic series is consisted by the natural numbers, while the mathematical harmonic series maps to the natural logarithm. So each of the harmonic series has ties to its own separate so-called natural concept.
It took some time for it to sink in for me that there was nothing and had never been anything inherently linking the musical harmonic series to base 2. This was so difficult to accept what with the ubiquity of music-speak of "octaves3 of the harmonic series". The harmonic series is linked to the logarithmicity of our pitch perception, yes, because it is a primal demonstration of it. But I could have picked any logarithmic scale I wanted to illustrate the logarithmicity of pitch perception: 2, 3, 5/4, e, whatever. The fact that every 2n entry in the harmonic series happens to sound "samey" — and that there's no other special ratio quite like that — was why I picked 2 as my base, but it has nothing inherently to do with this general logarithmicity of pitch perception.
3 A legacy word for the 2:1 ratio. Okay, this is an admittedly xenharmano-snarky footnote.
And it's here that we arrive at the kind of wild (to me anyhow) realization that the logarithmic aspects of the musical harmonic series and the mathematical harmonic series are completely unrelated. The spectrum of color imbued by the base 2 logarithmic lens through which we perceive pitch class equivalence has nothing to do with the fact that partial sums of sequences of reciprocals of its terms approximate a base e logarithm.
2 : hearing :: e : reasoning.
So the matharmonic scale in pitch space's doubly-curved-off-ness was accounted for by layering two different logarithms: it was already an ln in linear space, then it got plot on a log2 scale.
Naturally my next topic of wonderment became: if the base 2 logarithmicity of pitch class equivalence is a given, what if I deployed the mathematical harmonic series in all its base e logarithmic glory directly into that space?
In other words, what if I attempted to draw my matharmonic series — instead of my frequency chart — on my pitch chart, using its 2x intervals as my units?
Well alright, but how does it work to use the 2x interval as the unit of the mathematical harmonic series (which is again 1 + ½ + ⅓ + ¼ + ...)? I'll tell you that it's not multiplying repeatedly by these fractions of 2. That'd be too easy (again, as in wrong). In order to "pretend" our logarithmic scale is a linear scale, we have to express whatever we're "adding" or "subtracting" in terms of a power of 2 which we would then multiply by.
You may think that notion sounds ridiculous, but believe it or not this is most likely how most of your interactions with musical pitch have gone in your life. If you've been participating in the standard Western tuning system (e.g. classical, jazz, pop, rock, most music), then whenever you treated pitch linearly, say, by counting up twelve equal steps from A4 to A5, adding one step at a time (A4, B♭4, B4, C5, D♭5, D5, E♭5, E5, F5, F♯5, G5, G♯5, A5), what you were actually doing under the hood was multiplying the frequency of your pitch by the twelfth root of 2, and you did it twelve times in a row.
A root just being a power less than 1, and the nth root of 2 just being another way of saying "multiply n of me together to get 2". Just like how the square root of 2 aka √2 aka 2½ is the number you multiply by itself to get 2, i.e. you multiply two of it together to get 2.
Try it yourself! The twelfth root of 2 ≈ 1.059463. Multiply twelve of those together and you get 2. The frequency of A4 is 440 Hz, Bb4 is 466.16, and B4 is 493.88. Both 466.16 / 440 and 493.88 / 466.16 ≈ 1.059463.
And 493.88 / 440 is the sixth root of 2 aka 2⅙, which you may recall that you can sum powers when multiplying like bases e.g. x2 ⋅ x3 = x5 (and of course 1/12 + 1/12 = 1/6). What this demonstrates clearly is how expressing pitches in terms of powers of 2 has given us the power to gear down one mathematical order of complexity from multiplication to addition. Multiplying twelve 12th roots of 2 would involve us summing their powers up to 12 / 12, and of course 2^(12/12) = 2^1 = 2.
Enough explanation. Back to the task at hand. We're going to take the terms of the mathematical harmonic series and create a new sequence which is those as powers/roots of 2. Then we'll create a new series out of that sequence. Except that since our terms aren't terms but factors (i.e. we're gonna multiply them, not add them), we'll use the Big Pi notation:
or, since the radical sign is radical dudes,
Then we'll consider the partial products of this, using those as multipliers on some base frequency. In other words, the first step of our new musical series will be the base. The second step will be 2 times the frequency of the base. The third step will be 2√2 = 2^(3/2) its frequency. The fourth step will be 2 ⋅ √2 ⋅ 3√2 = 2^(11/6). Then fifth step 2^(25/12), sixth 2^(137/60), etc. (you're recognizing these powers, right?)
Here's what that sounds like:
And here's what that looks like on our frequency and pitch charts1:
1 As we might have expected, we get a slightly more curved-off line than the traditional harmonic series. It helps me anyway to think of it this way, in terms of the definition of a logarithm (which we have thus far gotten away with ignoring): the number you'd have to raise your logarithmic base to get a given number. So when you look at a base 2 logarithmic graph, you're not surprised that you reach y = 1 once x = 2, y = 2 once x = 4, and y = 3 once x = 8, because 21 = 2, 22 = 4, and 23 = 8, respectively. Accordingly, when you look at a base e logarithmic graph, you're not surprised that you reach y = 1 once x = e, and y = 2 once x = e2. So since in the base e logarithmic graph you don't reach y = 2 until x = e2 ≈ 7.389056, but you reach it by x = 4 in the base 2 logarithmic graph, it's clear that the base e version rises more slowly. In fact, the larger the number you use for your base (10 is also common) the increasingly extremely curved off your curve will be.
Due to our fudging of the matharmonic series, it actually is "beating" the edharmonic series for just a couple steps before it is forever overtaken.
If you are familiar with some microtonal/xenharmonic terminology, you can also think of this as moving upwards first by one step of 1ed2, then by one step of 2ed2, then by one step of 3ed2, etc.2 And thus I dub thees new series the "2-edharmonic series" or — since 2 will be assumed if left unspecified — the "edharmonic series"3.
2 Because the 12ed2 that is the standard Western tuning is so highly composite, you can
hear the
first five
pitches of this new series on your guitar or piano. Start on any fret/key. Then go up by twelve frets/keys.
Then
go up by six frets/keys. Then by four. Then by three. It's not until you get to the step of 5ed2 that
you first
encounter a pitch interval unable to be expressed in terms of 12ed2 steps (i.e 1ed2 -> 12 * 1/12,
2ed2 -> 6
* 1/12, 3ed2 -> 4 * 1/12, 4ed2 -> 3 * 1/12). You could also think of this as moving by 1200
cents, then 600
cents, then 400, then 300, and it's only once you get to 240 that you're not a multiple
of 100.
3 I tried to find if there was some preexisting name for the nth root series or nth root product,
but I couldn't find one.
As teased in section §1, you can make an edharmonic series out of any positive factor you want. Here's one that might be of interest:
I think the matharmonic series and the edharmonic series are probably the most interesting of these new harmonic series. One is approximations of e; the other is that which once you put it into base 2 it approximates e.
I suppose you could also experiment with doing a log2 in frequency and then seeing it get log2'd again by pitch. But I wouldn't think it'd be so interesting. Basically just shooting for points in the traditional harmonic series, but instead of taking 1 step to reach each next one, taking 2n steps. And here's where I admit that this all made a great story and all, but that my actual experience of questioning, learning, and ideating here was so clumsy, out-of-order, and chaotic that I probably couldn't even relate it if I thought it would be a good idea to do so. I think I actually began at the ending here, by coming up with the edharmonic series out of nowhere, in terms of steps of shrinking ed2's. Although there is some truth to questioning the relationship between the music and math versions of the harmonic series, so probably my experience was something like working forwards and backwards through this stuff sameltimeously, meeting at several points in the middle. You'll just have to deal with this idealized take on what it might have been like to come up with this stuff semi-straightforwardly.
If you are interested in more harmonic series related hijinx, feel free to check out my "harmonic circle" or keeping reading here to learn about the "third tritave of odd harmonics".
If say you want to adjust the root, hear chords, change the speed, combine series, etc. you can do all that here and more.
Since the matharmonic and edharmonic series are not anchored by the octave in the same way as the traditional harmonic series, and their lower steps are the relatively more interesting ones, perhaps the best pieces to compose with them would involve kind of regular resetting to the root and/or switching to move subharmonically.
But until then, here are some Scala files for scales which are all octave-repeating (again despite the matharmonic or edharmonic scales not repeating the octave interval regularly) if you just want to try to improv something maybe:
4th
octave of the traditional harmonic series
! 4th-octave-harmonic-scale.scl
!
The 4th octave of the harmonic series, harmonics 8-15
8
!
9/8
5/4
11/8
3/2
13/8
7/4
15/8
2/1
Octaves 1-3 of the matharmonic series
! octaves-1-through-3-matharmonic-scale.scl
!

Add steps of successive ed2s (1200 cents + 600 + 400 + 300 + 240 ...)
29
!
23.85281
100.00000
123.85281
216.16051
301.87479
340.00000
381.87479
456.87479
527.46303
540.00000
594.12969
600.00000
657.28759
711.42857
717.28759
774.43045
828.97590
861.42857
881.14981
931.14981
979.14981
994.76190
1000.00000
1025.30366
1069.74810
1112.60525
1114.76190
1153.98456
1193.98456
1200
Back at Untwelve Summer Camp 2016 this idea popped in my head: what if we only used odd members of the harmonic series?
Listening to the odds from the harmonic series is one thing, and sounds nice and interesting enough:
I wanted to make a repeating scale out of this, but I was thwarted because an octave-repeating scale essentially introduces even harmonics, e.g. the 5th harmonic copy-pasted up an octave sounds like the (5 * 2)th harmonic.
This idea sat on the cutting room floor for a few weeks then before I had an "aha" moment on my xenharmonic series, realizing that there was nothing inherently linking the harmonic series to the octave. I could also look at tritaves of the harmonic series, and make a tritave-repeating scale.
As a bonus this would solidify the connection between this idea and the one from which the tritave arose: the Bohlen-Pierce Scale, which is based on harmonic intervals eschewing 2 as a factor. So here's me going up and then back down three tritaves of this tritave-repeating harmonic scale.
Here is the scala file:
Third
Tritave of Odd Harmonics
! 3rd-tritave-odd-harmonics.scl
!
Odds from the 3rd tritave of the harmonic series
9
!
11/9
13/9
5/3
17/9
19/9
7/3
23/9
25/9
3/1
If you look at the ratios between successive members of the harmonic series, they all superparticular ratios, that is, of the form (n+1)/n. But what if you made a scale out of these superparticular ratios themselves?
2/1, 3/2, 4/3, 5/4, 6/5...
As you can see, the scale is descending in pitch, as the subharmonic series does. In fact, the superparticular series can be thought of as a harmonic series multiplied by a subharmonic series. Of course if it was that simple the scales would just cancel out and you'd have a endless series of 1, 1, 1, 1, ... But if you offset the harmonic series and the subharmonic series by 1 step, then you can get superparticular series.
If you offset them in the other direction, you get the subparticular series:
1/2, 2/3, 3/4, 4/5, 5/6...
Where every member is a subparticular ratio, of the form n/(n+1). Much less is said about subparticular ratios (compare 68,000 Google hits for subparticular and basically none for subparticular). But I see no reason not to make the generalization. You can see that like the standard harmonic series, the subparticular series ascends in pitch.
Next I propose the duperparticular series:
3/1, 4/2, 5/3, 6/4, 7/5, ...
The name comes from "super duper", the objectively hilarious reduplicative of the adjective "super". What's happening now is that every entry in the series is of the form (n+2)/n. Of course I do not find anything in the literature about duperparticular ratios, because they are a silly thing, but the scale is interesting. Note that as a consequence of being off by 2, every other entry in this series is not going to be in lowest terms right off the bat, because it will be a ratio of two even numbers to each other.
Finally I propose the dubparticular series, which is the cross-pollination of the idea behind the duperparticular series and subparticular series:
1/3, 2/4, 3/5, 4/6, 5/7, ...
You can continue to create scales in this family, but I'm sure what you'd name them, or if they'd be of much interest.
By the way, the intervals of the superparticular series follow an interesting pattern: they are all subparticular ratios, each one the next one where the denominator is a square number. That is, from 2/1 to 3/2 is 3/4, 3/2 to 4/3 is 8/9, 4/3 to 5/4 is 15/16, 5/4 to 6/5 is 24/25, etc.
If you'd like to hear a song I've composed using these four scales, along with the standard harmonic and subharmonic series, check it out here: https://soundcloud.com/cmloegcmluin/zdaubyaos It also uses these ratios extensively in its rhythms.
I came up with the name "denominated harmonic series" before I noticed that they were already named and well-described and explored. More info here: https://en.xen.wiki/w/Overtone_scales#Over-n_Scales


The PlayStation Now November lineup will steal your heart
And you'll never see it coming.
by AshThree games are coming to PlayStation Now this November, with two marquee games available for a limited time and one game set to stay.
PlayStation Now received a huge price drop back at the start of October, with subscription prices being cut almost in half in most regions and a new feature known as “marquee games” being added. Subscribers to PlayStation Now have access to over 800 PlayStation 2, 3, and 4 games, which can be played on both PlayStation 4 and Windows PC thanks to the power of cloud gaming.
For those out of the loop: PlayStation Now’s marquee games are games that will rotate back out of the service after a set period of time – hence the term “marquee games.”
Heading the lineup is the iconic Persona 5, which will be available to download (PlayStation 4 only) and stream until the 4th of February, 2020. Yes – you can finally play Persona 5 on your Windows PC thanks to the power of game streaming!
Uncover the picaresque story of a young team of Phantom Thieves in this latest addition to the critically acclaimed Persona series, Persona 5.  After school, use your Metaverse Navigator smartphone app to infiltrate Palaces–surreal worlds created from the hearts of corrupt adults–and slip away to your double life as a Phantom Thief.
Next up is Middle-Earth: Shadow of War, which is available to stream and download until the 4th of February 2020.
With Middle-Earth: Shadow of War, go behind enemy lines to forge your army, conquer Fortresses and dominate Mordor from within. Experience how the award winning Nemesis System creates unique personal stories with every enemy and follower, and confront the full power of the Dark Lord Sauron and his Ringwraiths in this epic new story of Middle-earth.
Last, but definitely not least, is Hollow Knight. Hollow Knight is set to stay on PlayStation Now, so you don’t need to worry about completing it before a deadline.
Descend into the world of Hollow Knight! The award winning action adventure of insects and heroes. Explore twisting caverns, ancient cities and deadly wastes. Battle tainted creatures and befriend bizarre bugs. Uncover ancient history and solve the mysteries buried at the kingdom’s heart.
If these three weren’t enough to tempt you, even though Persona 5 is right there, then consider the fact that you can also play God of War, Grand Theft Auto V, inFAMOUS Second Son, and Uncharted 4: A Thief’s End on PlayStation Now. All four of these games will be available to stream and download until January 2nd, 2020, so get to it!
For more information, including how to get your seven-day free trial, you can head over to the official PlayStation Now website by following the link here.


|
ActiveTcl User Guide
|
||
focus - Manage the input focus
focus
focus window
focus option ?arg arg ...?
The focus command is used to manage the Tk input focus. At any given time, one window on each display is designated as the focus window; any key press or key release events for the display are sent to that window. It is normally up to the window manager to redirect the focus among the top-level windows of a display. For example, some window managers automatically set the input focus to a top-level window whenever the mouse enters it; others redirect the input focus only when the user clicks on a window. Usually the window manager will set the focus only to top-level windows, leaving it up to the application to redirect the focus among the children of the top-level.
Tk remembers one focus window for each top-level (the most recent descendant of that top-level to receive the focus); when the window manager gives the focus to a top-level, Tk automatically redirects it to the remembered window. Within a top-level Tk uses an explicit focus model by default. Moving the mouse within a top-level does not normally change the focus; the focus changes only when a widget decides explicitly to claim the focus (e.g., because of a button click), or when the user types a key such as Tab that moves the focus.
The Tcl procedure tk_focusFollowsMouse may be invoked to create an implicit focus model: it reconfigures Tk so that the focus is set to a window whenever the mouse enters it. The Tcl procedures tk_focusNext and tk_focusPrev implement a focus order among the windows of a top-level; they are used in the default bindings for Tab and Shift-Tab, among other things.
The focus command can take any of the following forms:
When an internal window receives the input focus, Tk doesn't actually set the X focus to that window; as far as X is concerned, the focus will stay on the top-level window containing the window with the focus. However, Tk generates FocusIn and FocusOut events just as if the X focus were on the internal window. This approach gets around a number of problems that would occur if the X focus were actually moved; the fact that the X focus is on the top-level is invisible unless you use C code to query the X server directly.
events, focus, keyboard, top-level, window manager
Copyright © 1990-1994 The Regents of the University of California. Copyright © 1994-1996 Sun Microsystems, Inc. Copyright © 1995-1997 Roger E. Critchlow Jr.


Mum accused of giving son Tyler Peck drugs claims witnesses 'bribed' to tell lies
Holly Strawbridge, aged 34, said in interview that the 15-year-old friend's were offered money after his death
by Stuart AbelA mother accused of supplying the drugs which killed her schoolboy son has accused her ex-partner of bribing the 15-year-old’s friends to tell lies about her.
Holly Strawbridge, aged 34, told police that teenagers were making up things abut her because they were being given money by Tyler Peck’s father.
Mother-of-five Strawbridge is on on trial accused of giving Tyler and a 15-year-old friend her morphine and other painkilling medication at the family home in Salcombe.
Tyler Peck died from an overdose in his sleep that February night.
The trial resumed today after being adjourned on Friday after Strawbridge learnt of the unexpected death of her own mother.
The jury today heard the police interview Strawbridge gave in June.
She was asked why Tyler’s friends had lied about her supplying drugs – particularly the 15-year-old who said they spent the early hours abusing her medication.
He said that the three of them had also sniffed from aerosols.
Tyler died from an overdose of morphine and Gabapentin, with Valium, codeine and MDMA also found in his system.
Asked why the 15-year-old and other friends were lying about her, Strawbridge blamed ex-partner Ryan Peck.
She added: “He is a man who can get to them. He is probably giving them all money.”
Asked what money she was talking about, she said that it was £3,000 raised for Tyler’s funeral.
Officer in the case DC Mike Lugger asked Strawbridge: “Can you give me anything concrete? This would be perverting the course of justice.”
Strawbridge replied: “I have just given you it.”
She had earlier denied supplying the two 15-year-olds or anyone else with drugs.
Strawbridge said: “I just want to say that I have never supplied any sort of drugs. I had nothing to do with Tyler’s death or any allegations that they, people, are saying.”
She told police in her initial interview that she had put Tyler to sleep that night.
The court heard a statement from Andy Pugsley, the headteacher of Salcombe Primary School.
He said that the school decided to set up a crowdfunding page in the wake of Tyler’s death.
Mr Pugsley added that the aim was to raise £1,500 to pay for the funeral, but £3,000 was collected.
He added that the excess money was split between four schools attended by Tyler and his brothers and sisters.
The Crown Prosecution Service has closed its case, but for verifying one fact.
Strawbridge has pleaded not guilty to supplying Tyler and the other boy with morphine between January 31 and February 3.
The defendant has also denies two further charges of cruelty towards the two boys between the same dates.
The trial continues.


The next type of loops were going to discuss are called for loops.
For loops are actually just slightly modified versions of while loops which we looked at in a previous lesson. But for loops can make your life as a programmer a lot easier because they simplify a commonly used while loop structure.
The concept is the same a while loop, you’re checking some boolean expression on each iteration of the loop and executing a block of code if it’s true. However a for loop gives us the added ability of being able to include an index variable.
To fully explain for loops it will help to compare them to while loops. Take a look at the while loop below that we wrote in a previous lesson:
{{ partial "shortcodes/code" (dict "lang" (.Get "code-lang") "file" "" "Content" $.Page.Params.code.a ) }}
Notice how in the code above I've declared a variable, index
. This variable is used to count the number of times the computer has printed to the screen.
Using counting variables like this is actually a very common and useful tactic. But when we use a while loop we have to go through the trouble of declaring the variable before the loop itself and then manually incrementing it inside the loop body.
Because programmers used counting, or indexing variables like this so often, the for loop was created to simplify the process. Essentially a for loop is used to iterate through a block of code a specified number of times, with the use of an iterative variable (the index variable for example).
Check out this same program below, but this time written with a for loop instead of a while loop:
{{ partial "shortcodes/code" (dict "lang" (.Get "code-lang") "file" "" "Content" $.Page.Params.code.b ) }}
First thing you should notice about the above code is the structure. The declaration of a for loop contains three main parts
(declaring or specifying a counting variable ; boolean expression ; iterative action)
It starts, in the first segment by either declaring or specifying a counting variable. This is called the iterative variable and it is used for that purpose. This is the variable which counts how many times the computer has printed to the screen. It has become practice to name this variable i
, which stands for iterator.
The next section of the for loop declaration is the boolean expression. This boolean expression acts the same as it does in the while loop, ultimately this is going to determine whether or not the code inside the loop gets executed on each iteration. Most of the time this boolean expression is going to be checking the value of the iterative variable (i) against some other value.
Finally the last section in the for loop declaration is a piece of code which gets executed at the end of each iteration. 99% of the time this is either going to increment (add to) or decrement (subtract from) the iterative variable.
In our case we are incrementing the variable by one on each iteration, which makes sense. By placing this in the declaration we save space in the body of the loop and make the whole structure cleaner.
{{ partial "shortcodes/spotlight" (dict "Content" "It's important to emphasize again that a for loop is just a specialized version of a while loop. There's nothing you can do with a for loop that you can't also do with a while loop. That being said, in my opinion for loops are used a lot more in programs because they are so convenient. " ) }}
Being able to write efficient and effective loops is a skill all programmers must master. Study the examples above and try some of your own and you’ll be on your way to success.


Phrases submitted: 0
Ultimate Charades is a unique take on the classic party game. The goal is to see which team can guess the most phrases over three rounds. Each round uses the same phrases, so be sure to pay attention while the other team gives clues too.
The timer will begin once you start.
You are guessing.
The other team is guessing.
This round has ended. Check the score on the screen.
Please wait until the next game begins.


Cayetano dismisses Robredo as ‘all talk’
by Jester P. ManalastasTHE Vice President has turned the drug war into “Operation All Talk,” Speaker Alan Peter Cayateno said betraying his dismay over Vice President Leni Robredo as lead campaigner against the drug menace.
According to Cayetano, Robredo is “all talk” when it comes to solving the problem of illegal drugs.
Last week President Rodrigo Duterte appointed Robredo as co-chairman of the Inter-Agency Committee on Anti-Illegal Drugs (ICAD).
Following her acceptance of the position, Robredo proposed the scrapping of Oplan Tokhang as well as opening the campaign against illegal drugs to the United Nations probe.
“I’ve been monitoring the last three days and parang from Oplan Tokhang, naging Operation All Talk. I guess it just so happens that the Vice President is a favorite of the media or she likes media exposure,” Cayetano said in an interview.
He also said Robredo has started “on the wrong mouth” and has not yet called a briefing from other agencies but already spewing out ideas and criticisms.
“Now she’s saying magpapa-briefing sa lahat ng department at lahat agencies, eh hindi pa pala nagbriefing, so why already these ideas,” Cayetano said.
Cayetano appealed to Robredo to stop politicking on the issue of illegal drugs but instead respect what the administration has started.
“Dapat tanggalin ang politics whether from the opposition or the administration when it comes to the drug war,” he stressed.
He said that the success of the ICAD and Robredo is the success of the whole country.