Russian Mishina and Galyamov Win Pairs Figure Skating Gold at Gran Prix Stage in Grenoble
World junior champions Anastasia Mishina and Alexander Gallyamov from Russia took first in the pairs’ discipline at the 2019 – 2020 International Skating Union (ISU) Grand Prix in France.
The pair won free routines, with 207,58 points total.
Another Russian pair, Daria Pavlyuchenko and Denis Khodykin, won silver medal, with 206,56 points total. They were in the first place after the pairs' short program in Grenoble, but got only 129.97 points in free skating on Saturday.
Haven Danny and Brandon Frazier took bronze for the United States, with a total of 199,40.
Earlier on Saturday, Russian figure skater Alena Kostornaia won gold in the Grand Prix ladies' singles discipline, while her compatriot Alina Zagitova won silver.


index
|
up
|
prev
|
next
MemberFailureAction<Type> Class
Definition at line
46
of
Action.hpp
Constructors
MemberFailureAction
(Type* type_,
void
type_)
Member Functions
void
operator()
(
ParsingData
* parsingData)
const override
Member Variables
Type*
type
Constructor Details
MemberFailureAction Constructor
cmajor::parsing::MemberFailureAction::MemberFailureAction(Type* type_,
void
type_)
Definition at line
49
of
Action.hpp
:
49
:
50
type
(
type_
)
,
memfun
(
pm
)
51
{
52
}
Member Function Details
operator() Member Function
void
cmajor::parsing::MemberFailureAction::operator()(
ParsingData
* parsingData)
const override
Definition at line
53
of
Action.hpp
:
54
{
55
(
type
->*
memfun
)
(
parsingData
)
;
56
}
Base class overridden functions:
cmajor::parsing::FailureAction::operator()
index
|
up
|
prev
|
next


Registration Page
First Name:
Last Name:
Address:
City:
Redding
San Francisco
Fresno
Los Angeles
State:
CA
WA
TX
PA
Zip Code:
Date of Birth:
Male
Female
Other
Comments:


The implementation class of the set returned by keySet
.
The implementation class of the iterable returned by values
.
The type implementing this traversable
A class supporting filtered operations.
o != arg0
is the same as !(o == (arg0))
.
o != arg0
is the same as !(o == (arg0))
.
the object to compare against this object for dis-equality.
false
if the receiver object is equivalent to the argument; true
otherwise.
[use case] Adds all key/value pairs in a traversable collection to this map, returning a new map.
Adds all key/value pairs in a traversable collection to this map, returning a new map.
the collection containing the added key/value pairs
a new map with the given bindings added to this map
[use case] Adds key/value pairs to this map, returning a new map.
Adds key/value pairs to this map, returning a new map.
the remaining key/value pairs
a new map with the given bindings added to this map
Adds key/value pairs to this map, returning a new map.
Adds key/value pairs to this map, returning a new map.
This method takes two or more key/value pairs. Another overloaded variant of this method handles the case where a single key/value pair is added.
the type of the added values
the first key/value pair
the second key/value pair
the remaining key/value pairs
a new map with the given bindings added to this map
[use case] Adds a key/value pair to this map, returning a new map.
Adds a key/value pair to this map, returning a new map.
the key/value pair
a new map with the new binding added to this map
Adds a key/value pair to this map, returning a new map.
Adds a key/value pair to this map, returning a new map.
the type of the value in the key/value pair.
the key/value pair
a new map with the new binding added to this map
Adds all key/value pairs in a traversable collection to this map, returning a new map.
Adds all key/value pairs in a traversable collection to this map, returning a new map.
the type of the added values
a new map with the given bindings added to this map
[use case] Concatenates this map with the elements of a traversable collection.
Concatenates this map with the elements of a traversable collection.
the traversable to append.
a new map which contains all elements of this map
followed by all elements of that
.
Concatenates this map with the elements of a traversable collection.
Concatenates this map with the elements of a traversable collection.
the element type of the returned collection.
the class of the returned collection. Where possible, That
is
the same class as the current collection class Repr
, but this
depends on the element type B
being admissible for that class,
which means that an implicit instance of type CanBuildFrom[Repr, B, That]
is found.
the traversable to append.
an implicit value of class CanBuildFrom
which determines the
result class That
from the current representation type Repr
and
and the new element type B
.
a new collection of type That
which contains all elements of this map
followed by all elements of that
.
Creates a new map from this map with some elements removed.
Creates a new map from this map with some elements removed.
This method takes two or more elements to be removed. Another overloaded variant of this method handles the case where a single element is removed.
the first element to remove.
the second element to remove.
the remaining elements to remove.
a new map that contains all elements of the current map except one less occurrence of each of the given elements.
[use case] Removes a key from this map, returning a new map.
Removes a key from this map, returning a new map.
the key to be removed
a new map without a binding for key
Removes a key from this map, returning a new map.
Removes a key from this map, returning a new map.
the key to be removed
a new map without a binding for key
Creates a new map from this map by removing all elements of another collection.
Creates a new map from this map by removing all elements of another collection.
a new map that contains all elements of the current map
except one less occurrence of each of the elements of elems
.
Applies a binary operator to a start value and all elements of this map, going left to right.
Applies a binary operator to a start value and all elements of this map, going left to right.
Note: /:
is alternate syntax for foldLeft
; z /: xs
is the same as xs foldLeft z
.
Note: might return different results for different runs, unless the underlying collection type is ordered. or the operator is associative and commutative.
the result type of the binary operator.
the start value.
the binary operator.
the result of inserting op
between consecutive elements of this map,
going left to right with the start value z
on the left:
op(...op(op(z, x1), x2), ..., xn)
where x,,1,,, ..., x,,n,,
are the elements of this map.
Applies a binary operator to all elements of this map and a start value, going right to left.
Applies a binary operator to all elements of this map and a start value, going right to left.
Note: :\
is alternate syntax for foldRight
; xs :\ z
is the same as xs foldRight z
.
Note: might return different results for different runs, unless the underlying collection type is ordered. or the operator is associative and commutative.
the result type of the binary operator.
the start value
the binary operator
the result of inserting op
between consecutive elements of this map,
going right to left with the start value z
on the right:
op(x1, op(x2, ... op(xn, z)...))
where x,,1,,, ..., x,,n,,
are the elements of this map.
o == arg0
is the same as if (o eq null) arg0 eq null else o.equals(arg0)
.
o == arg0
is the same as if (o eq null) arg0 eq null else o.equals(arg0)
.
the object to compare against this object for equality.
true
if the receiver object is equivalent to the argument; false
otherwise.
o == arg0
is the same as o.equals(arg0)
.
o == arg0
is the same as o.equals(arg0)
.
the object to compare against this object for equality.
true
if the receiver object is equivalent to the argument; false
otherwise.
Appends all bindings of this map to a string builder using start, end, and separator strings.
Appends all bindings of this map to a string builder using start, end, and separator strings.
The written text begins with the string start
and ends with the string
end
. Inside, the string representations of all bindings of this map
in the form of key -> value
are separated by the string sep
.
the builder to which strings are appended.
the starting string.
the separator string.
the ending string.
the string builder b
to which elements were appended.
Appends all elements of this map to a string builder.
Appends all elements of this map to a string builder.
The written text consists of the string representations (w.r.t. the method toString
)
of all elements of this map without any separator string.
the string builder to which elements are appended.
the string builder b
to which elements were appended.
Appends all elements of this map to a string builder using a separator string.
Appends all elements of this map to a string builder using a separator string.
The written text consists of the string representations (w.r.t. the method toString
)
of all elements of this map, separated by the string sep
.
the string builder to which elements are appended.
the separator string.
the string builder b
to which elements were appended.
Composes this partial function with a transformation function that gets applied to results of this partial function.
Composes this partial function with a transformation function that gets applied to results of this partial function.
the result type of the transformation function.
the transformation function
a partial function with the same domain as this partial function, which maps
arguments x
to k(this(x))
.
Retrieves the value which is associated with the given key.
Retrieves the value which is associated with the given key. This
method invokes the default
method of the map if there is no mapping
from the given key to a value. Unless overridden, the default
method throws a
NoSuchElementException
.
the key
the value associated with the given key, or the result of the
map's default
method, if none exists.
This method is used to cast the receiver object to be of type T0
.
This method is used to cast the receiver object to be of type T0
.
Note that the success of a cast at runtime is modulo Scala's erasure semantics. Therefore the expression1.asInstanceOf[String]
will throw a ClassCastException
at runtime, while the expressionList(1).asInstanceOf[List[String]]
will not. In the latter example, because the type argument is erased as
part of compilation it is not possible to check whether the contents of the list are of the requested typed.
the receiver object.
Method called from equality methods, so that user-defined subclasses can refuse to be equal to other collections of the same kind.
Method called from equality methods, so that user-defined subclasses can refuse to be equal to other collections of the same kind.
The object with which this map should be compared
true
, if this map can possibly equal that
, false
otherwise. The test
takes into consideration only the run-time types of objects but ignores their elements.
This method creates and returns a copy of the receiver object.
This method creates and returns a copy of the receiver object.
The default implementation of the clone
method is platform dependent.
a copy of the receiver object.
[use case] Builds a new collection by applying a partial function to all elements of this map on which the function is defined.
Builds a new collection by applying a partial function to all elements of this map on which the function is defined.
the element type of the returned collection.
the partial function which filters and maps the map.
a new map resulting from applying the given partial function
pf
to each element on which it is defined and collecting the results.
The order of the elements is preserved.
Builds a new collection by applying a partial function to all elements of this map on which the function is defined.
Builds a new collection by applying a partial function to all elements of this map on which the function is defined.
the element type of the returned collection.
the class of the returned collection. Where possible, That
is
the same class as the current collection class Repr
, but this
depends on the element type B
being admissible for that class,
which means that an implicit instance of type CanBuildFrom[Repr, B, That]
is found.
the partial function which filters and maps the map.
an implicit value of class CanBuildFrom
which determines the
result class That
from the current representation type Repr
and
and the new element type B
.
a new collection of type That
resulting from applying the partial function
pf
to each element on which it is defined and collecting the results.
The order of the elements is preserved.
(f compose g)(x) == f(g(x))
(f compose g)(x) == f(g(x))
Tests whether this map contains a binding for a key.
Tests whether this map contains a binding for a key.
the key
true
if there is a binding for key
in this map, false
otherwise.
[use case] Copies elements of this map to an array.
Copies elements of this map to an array.
Fills the given array xs
with at most len
elements of
this map, starting at position start
.
Copying will stop once either the end of the current map is reached,
or the end of the array is reached, or len
elements have been copied.
the array to fill.
the starting index.
the maximal number of elements to copy.
Copies elements of this map to an array.
Copies elements of this map to an array.
Fills the given array xs
with at most len
elements of
this map, starting at position start
.
Copying will stop once either the end of the current map is reached,
or the end of the array is reached, or len
elements have been copied.
the type of the elements of the array.
the array to fill.
the starting index.
the maximal number of elements to copy.
[use case] Copies values of this map to an array.
Copies values of this map to an array.
Fills the given array xs
with values of this map.
Copying will stop once either the end of the current map is reached,
or the end of the array is reached.
the array to fill.
Copies values of this map to an array.
Copies values of this map to an array.
Fills the given array xs
with values of this map.
Copying will stop once either the end of the current map is reached,
or the end of the array is reached.
the type of the elements of the array.
the array to fill.
[use case] Copies values of this map to an array.
Copies values of this map to an array.
Fills the given array xs
with values of this map, after skipping start
values.
Copying will stop once either the end of the current map is reached,
or the end of the array is reached.
the array to fill.
the starting index.
Copies values of this map to an array.
Copies values of this map to an array.
Fills the given array xs
with values of this map, after skipping start
values.
Copying will stop once either the end of the current map is reached,
or the end of the array is reached.
the type of the elements of the array.
the array to fill.
the starting index.
Copies all elements of this map to a buffer.
Copies all elements of this map to a buffer.
The buffer to which elements are copied.
Counts the number of elements in the map which satisfy a predicate.
Counts the number of elements in the map which satisfy a predicate.
the predicate used to test elements.
the number of elements satisfying the predicate p
.
Defines the default value computation for the map, returned when a key is not found The method implemented here throws an exception, but it might be overridden in subclasses.
Defines the default value computation for the map, returned when a key is not found The method implemented here throws an exception, but it might be overridden in subclasses.
the given key value for which a binding is missing.
Selects all elements except first n ones.
Selects all elements except first n ones.
Note: might return different results for different runs, unless the underlying collection type is ordered.
the number of elements to drop from this map.
a map consisting of all elements of this map except the first n
ones, or else the
empty map, if this map has less than n
elements.
Selects all elements except last n ones.
Selects all elements except last n ones.
Note: might return different results for different runs, unless the underlying collection type is ordered.
The number of elements to take
a map consisting of all elements of this map except the first n
ones, or else the
empty map, if this map has less than n
elements.
Drops longest prefix of elements that satisfy a predicate.
Drops longest prefix of elements that satisfy a predicate.
Note: might return different results for different runs, unless the underlying collection type is ordered.
The predicate used to test elements.
the longest suffix of this map whose first element
does not satisfy the predicate p
.
use iterator' instead
The empty map of the same type as this map
The empty map of the same type as this map
an empty map of type This
.
This method is used to test whether the argument (arg0
) is a reference to the
receiver object (this
).
This method is used to test whether the argument (arg0
) is a reference to the
receiver object (this
).
The eq
method implements an [http://en.wikipedia.org/wiki/Equivalence_relation equivalence relation] on
non-null instances of AnyRef
:
* It is reflexive: for any non-null instance x
of type AnyRef
, x.eq(x)
returns true
.
* It is symmetric: for any non-null instances x
and y
of type AnyRef
, x.eq(y)
returns true
if and
only if y.eq(x)
returns true
.
* It is transitive: for any non-null instances x
, y
, and z
of type AnyRef
if x.eq(y)
returns true
and y.eq(z)
returns true
, then x.eq(z)
returns true
.
Additionally, the eq
method has three other properties.
* It is consistent: for any non-null instances x
and y
of type AnyRef
, multiple invocations of
x.eq(y)
consistently returns true
or consistently returns false
.
* For any non-null instance x
of type AnyRef
, x.eq(null)
and null.eq(x)
returns false
.
* null.eq(null)
returns true
.
When overriding the equals
or hashCode
methods, it is important to ensure that their behavior is
consistent with reference equality. Therefore, if two objects are references to each other (o1 eq o2
), they
should be equal to each other (o1 == o2
) and they should hash to the same value (o1.hashCode == o2.hashCode
).
the object to compare against this object for reference equality.
true
if the argument is a reference to the receiver object; false
otherwise.
Compares two maps structurally; i.
Tests whether a predicate holds for some of the elements of this map.
Tests whether a predicate holds for some of the elements of this map.
the predicate used to test elements.
true
if the given predicate p
holds for some of the elements
of this map, otherwise false
.
Selects all elements of this map which satisfy a predicate.
Selects all elements of this map which satisfy a predicate.
the predicate used to test elements.
a new map consisting of all elements of this map that satisfy the given
predicate p
. The order of the elements is preserved.
Filters this map by retaining only keys satisfying a predicate.
Filters this map by retaining only keys satisfying a predicate.
the predicate used to test keys
an immutable map consisting only of those key value pairs of this map where the key satisfies
the predicate p
. The resulting map wraps the original map without copying any elements.
Returns a new map with all key/value pairs for which the predicate
p
returns true
.
Returns a new map with all key/value pairs for which the predicate
p
returns true
.
Note: This method works by successively removing elements fro which the
predicate is false from this set.
If removal is slow, or you expect that most elements of the set
will be removed, you might consider using filter
with a negated predicate instead.
A predicate over key-value pairs
A new map containing elements not satisfying the predicate.
This method is called by the garbage collector on the receiver object when garbage collection determines that there are no more references to the object.
This method is called by the garbage collector on the receiver object when garbage collection determines that there are no more references to the object.
The details of when and if the finalize
method are invoked, as well as the interaction between finalize
and non-local returns and exceptions, are all platform dependent.
Finds the first element of the map satisfying a predicate, if any.
Finds the first element of the map satisfying a predicate, if any.
Note: might return different results for different runs, unless the underlying collection type is ordered.
the predicate used to test elements.
an option value containing the first element in the map
that satisfies p
, or None
if none exists.
use head' instead
None
if iterable is empty.
[use case] Builds a new collection by applying a function to all elements of this map and concatenating the results.
Builds a new collection by applying a function to all elements of this map and concatenating the results.
the element type of the returned collection.
the function to apply to each element.
a new map resulting from applying the given collection-valued function
f
to each element of this map and concatenating the results.
Builds a new collection by applying a function to all elements of this map and concatenating the results.
Builds a new collection by applying a function to all elements of this map and concatenating the results.
the element type of the returned collection.
the class of the returned collection. Where possible, That
is
the same class as the current collection class Repr
, but this
depends on the element type B
being admissible for that class,
which means that an implicit instance of type CanBuildFrom[Repr, B, That]
is found.
the function to apply to each element.
an implicit value of class CanBuildFrom
which determines the
result class That
from the current representation type Repr
and
and the new element type B
.
a new collection of type That
resulting from applying the given collection-valued function
f
to each element of this map and concatenating the results.
Applies a binary operator to a start value and all elements of this map, going left to right.
Applies a binary operator to a start value and all elements of this map, going left to right.
Note: might return different results for different runs, unless the underlying collection type is ordered. or the operator is associative and commutative.
the result type of the binary operator.
the start value.
the binary operator.
the result of inserting op
between consecutive elements of this map,
going left to right with the start value z
on the left:
op(...op(z, x1), x2, ..., xn)
where x,,1,,, ..., x,,n,,
are the elements of this map.
Applies a binary operator to all elements of this map and a start value, going right to left.
Applies a binary operator to all elements of this map and a start value, going right to left.
Note: might return different results for different runs, unless the underlying collection type is ordered. or the operator is associative and commutative.
the result type of the binary operator.
the start value.
the binary operator.
the result of inserting op
between consecutive elements of this map,
going right to left with the start value z
on the right:
op(x1, op(x2, ... op(xn, z)...))
where x,,1,,, ..., x,,n,,
are the elements of this map.
Tests whether a predicate holds for all elements of this map.
Tests whether a predicate holds for all elements of this map.
the predicate used to test elements.
true
if the given predicate p
holds for all elements
of this map, otherwise false
.
[use case] Applies a function f
to all elements of this map.
Applies a function f
to all elements of this map.
the function that is applied for its side-effect to every element.
The result of function f
is discarded.
Applies a function f
to all elements of this map.
Applies a function f
to all elements of this map.
Note: this method underlies the implementation of most other bulk operations. Subclasses should re-implement this method if a more efficient implementation exists.
the type parameter describing the result of function f
.
This result will always be ignored. Typically U
is Unit
,
but this is not necessary.
the function that is applied for its side-effect to every element.
The result of function f
is discarded.
Optionally returns the value associated with a key.
Optionally returns the value associated with a key.
the key value
an option value containing the value associated with key
in this map,
or None
if none exists.
Returns a representation that corresponds to the dynamic class of the receiver object.
Returns a representation that corresponds to the dynamic class of the receiver object.
The nature of the representation is platform dependent.
a representation that corresponds to the dynamic class of the receiver object.
[use case] Returns the value associated with a key, or a default value if the key is not contained in the map.
Returns the value associated with a key, or a default value if the key is not contained in the map.
the key.
a computation that yields a default value in case no binding for key
is
found in the map.
the value associated with key
if it exists,
otherwise the result of the default
computation.
Returns the value associated with a key, or a default value if the key is not contained in the map.
Returns the value associated with a key, or a default value if the key is not contained in the map.
the result type of the default computation.
the key.
a computation that yields a default value in case no binding for key
is
found in the map.
the value associated with key
if it exists,
otherwise the result of the default
computation.
Partitions this map into a map of maps according to some discriminator function.
Partitions this map into a map of maps according to some discriminator function.
Note: this method is not re-implemented by views. This means when applied to a view it will always force the view and return a new map.
the type of keys returned by the discriminator function.
the discriminator function.
A map from keys to maps such that the following invariant holds:
(xs partition f)(k) = xs filter (x => f(x) == k)
That is, every key k
is bound to a map of those elements x
for which f(x)
equals k
.
Partitions elements in fixed size maps.
Partitions elements in fixed size maps.
the number of elements per group
An iterator producing maps of size size
, except the
last will be truncated if the elements don't divide evenly.
Iterator#grouped
Tests whether this map is known to have a finite size.
Tests whether this map is known to have a finite size.
All strict collections are known to have finite size. For a non-strict collection
such as Stream
, the predicate returns true
if all elements have been computed.
It returns false
if the stream is not yet evaluated to the end.
Note: many collection methods will not work on collections of infinite sizes.
true
if this collection is known to have finite size, false
otherwise.
Returns a hash code value for the object.
Returns a hash code value for the object.
The default hashing algorithm is platform dependent.
Note that it is allowed for two objects to have identical hash codes (o1.hashCode.equals(o2.hashCode)
) yet
not be equal (o1.equals(o2)
returns false
). A degenerate implementation could always return 0
.
However, it is required that if two objects are equal (o1.equals(o2)
returns true
) that they have
identical hash codes (o1.hashCode.equals(o2.hashCode)
). Therefore, when overriding this method, be sure
to verify that the behavior is consistent with the equals
method.
the hash code value for the object.
Selects the first element of this map.
Selects the first element of this map.
Note: might return different results for different runs, unless the underlying collection type is ordered.
the first element of this map.
Optionally selects the first element.
Optionally selects the first element.
Note: might return different results for different runs, unless the underlying collection type is ordered.
the first element of this map if it is nonempty, None
if it is empty.
Selects all elements except the last.
Selects all elements except the last.
Note: might return different results for different runs, unless the underlying collection type is ordered.
a map consisting of all elements of this map except the last one.
Tests whether this map contains a binding for a key.
Tests whether this map contains a binding for a key. This method,
which implements an abstract method of trait PartialFunction
,
is equivalent to contains
.
the key
true
if there is a binding for key
in this map, false
otherwise.
Tests whether the map is empty.
Tests whether the map is empty.
true
if the map does not contain any key/value binding, false
otherwise.
This method is used to test whether the dynamic type of the receiver object is T0
.
This method is used to test whether the dynamic type of the receiver object is T0
.
Note that the test result of the test is modulo Scala's erasure semantics. Therefore the expression1.isInstanceOf[String]
will return false
, while the expression List(1).isInstanceOf[List[String]]
will
return true
. In the latter example, because the type argument is erased as part of compilation it is not
possible to check whether the contents of the list are of the requested typed.
true
if the receiver object is an instance of erasure of type T0
; false
otherwise.
Tests whether this map can be repeatedly traversed.
Tests whether this map can be repeatedly traversed.
true
Creates a new iterator over all key/value pairs of this map
Creates a new iterator over all key/value pairs of this map
the new iterator
Collects all keys of this map in a set.
Collects all keys of this map in a set.
a set containing all keys of this map.
Creates an iterator for all keys.
Creates an iterator for all keys.
an iterator over all keys.
Creates an iterator for all keys.
Creates an iterator for all keys.
an iterator over all keys.
Selects the last element.
Selects the last element.
Note: might return different results for different runs, unless the underlying collection type is ordered.
the first element of this map.
Optionally selects the last element.
Optionally selects the last element.
Note: might return different results for different runs, unless the underlying collection type is ordered.
the last element of this map$ if it is nonempty, None
if it is empty.
Turns this partial function into an plain function returning an Option
result.
Turns this partial function into an plain function returning an Option
result.
a function that takes an argument x
to Some(this(x))
if this
is defined for x
, and to None
otherwise.
[use case] Builds a new collection by applying a function to all elements of this map.
Builds a new collection by applying a function to all elements of this map.
the element type of the returned collection.
the function to apply to each element.
a new map resulting from applying the given function
f
to each element of this map and collecting the results.
Builds a new collection by applying a function to all elements of this map.
Builds a new collection by applying a function to all elements of this map.
the element type of the returned collection.
the class of the returned collection. Where possible, That
is
the same class as the current collection class Repr
, but this
depends on the element type B
being admissible for that class,
which means that an implicit instance of type CanBuildFrom[Repr, B, That]
is found.
the function to apply to each element.
an implicit value of class CanBuildFrom
which determines the
result class That
from the current representation type Repr
and
and the new element type B
.
a new collection of type That
resulting from applying the given function
f
to each element of this map and collecting the results.
use mapValues' instead
Transforms this map by applying a function to every retrieved value.
Transforms this map by applying a function to every retrieved value.
the function used to transform values of this map.
a map view which maps every key of this map
to f(this(key))
. The resulting map wraps the original map without copying any elements.
[use case] Finds the largest element.
Finds the largest element.
the largest element of this map.
Finds the largest element.
Finds the largest element.
The type over which the ordering is defined.
An ordering to be used for comparing elements.
the largest element of this map with respect to the ordering cmp
.
[use case] Finds the smallest element.
Finds the smallest element.
the smallest element of this map
Finds the smallest element.
Finds the smallest element.
The type over which the ordering is defined.
An ordering to be used for comparing elements.
the smallest element of this map with respect to the ordering cmp
.
Displays all elements of this map in a string.
Displays all elements of this map in a string.
a string representation of this map. In the resulting string
the string representations (w.r.t. the method toString
)
of all elements of this map follow each other without any separator string.
Displays all elements of this map in a string using a separator string.
Displays all elements of this map in a string using a separator string.
the separator string.
a string representation of this map. In the resulting string
the string representations (w.r.t. the method toString
)
of all elements of this map are separated by the string sep
.
Displays all elements of this map in a string using start, end, and separator strings.
Displays all elements of this map in a string using start, end, and separator strings.
the starting string.
the separator string.
the ending string.
a string representation of this map. The resulting string
begins with the string start
and ends with the string
end
. Inside, the string representations (w.r.t. the method toString
)
of all elements of this map are separated by the string sep
.
o.ne(arg0)
is the same as !(o.eq(arg0))
.
o.ne(arg0)
is the same as !(o.eq(arg0))
.
the object to compare against this object for reference dis-equality.
false
if the argument is not a reference to the receiver object; true
otherwise.
A common implementation of newBuilder
for all maps in terms of empty
.
A common implementation of newBuilder
for all maps in terms of empty
.
Overridden for mutable maps in mutable.MapLike
.
Tests whether the map is not empty.
Tests whether the map is not empty.
true
if the map contains at least one element, false
otherwise.
Wakes up a single thread that is waiting on the receiver object's monitor.
Wakes up a single thread that is waiting on the receiver object's monitor.
Wakes up all threads that are waiting on the receiver object's monitor.
Wakes up all threads that are waiting on the receiver object's monitor.
Composes this partial function with a fallback partial function which gets applied where this partial function is not defined.
Composes this partial function with a fallback partial function which gets applied where this partial function is not defined.
the argument type of the fallback function
the result type of the fallback function
the fallback function
a partial function which has as domain the union of the domains
of this partial function and that
. The resulting partial function
takes x
to this(x)
where this
is defined, and to that(x)
where it is not.
Partitions this map in two maps according to a predicate.
Partitions this map in two maps according to a predicate.
the predicate on which to partition.
a pair of maps: the first map consists of all elements that
satisfy the predicate p
and the second map consists of all elements
that don't. The relative order of the elements in the resulting maps
is the same as in the original map.
[use case] Multiplies up the elements of this collection.
Multiplies up the elements of this collection.
the product of all elements in this map of numbers of type Int
.
Instead of Int
, any other type T
with an implicit Numeric[T]
implementation
can be used as element type of the map and as result type of product
.
Examples of such types are: Long
, Float
, Double
, BigInt
.
Multiplies up the elements of this collection.
Multiplies up the elements of this collection.
the result type of the *
operator.
an implicit parameter defining a set of numeric operations
which includes the *
operator to be used in forming the product.
the product of all elements of this map with respect to the *
operator in num
.
returns a projection that can be used to call non-strict filter
,map
, and flatMap
methods that build projections
of the collection.
returns a projection that can be used to call non-strict filter
,map
, and flatMap
methods that build projections
of the collection.
use view' instead
Applies a binary operator to all elements of this map, going left to right.
Applies a binary operator to all elements of this map, going left to right.
Note: might return different results for different runs, unless the underlying collection type is ordered. or the operator is associative and commutative.
the result type of the binary operator.
the binary operator.
the result of inserting op
between consecutive elements of this map,
going left to right:
op(...(op(x1, x2), ... ) , xn)
where x,,1,,, ..., x,,n,,
are the elements of this map.
Optionally applies a binary operator to all elements of this map, going left to right.
Optionally applies a binary operator to all elements of this map, going left to right.
Note: might return different results for different runs, unless the underlying collection type is ordered. or the operator is associative and commutative.
the result type of the binary operator.
the binary operator.
an option value containing the result of reduceLeft(op)
is this map is nonempty,
None
otherwise.
Applies a binary operator to all elements of this map, going right to left.
Applies a binary operator to all elements of this map, going right to left.
Note: might return different results for different runs, unless the underlying collection type is ordered. or the operator is associative and commutative.
the result type of the binary operator.
the binary operator.
the result of inserting op
between consecutive elements of this map,
going right to left:
op(x1, op(x2, ..., op(xn-1, xn)...))
where x,,1,,, ..., x,,n,,
are the elements of this map.
Optionally applies a binary operator to all elements of this map, going right to left.
Optionally applies a binary operator to all elements of this map, going right to left.
Note: might return different results for different runs, unless the underlying collection type is ordered. or the operator is associative and commutative.
the result type of the binary operator.
the binary operator.
an option value containing the result of reduceRight(op)
is this map is nonempty,
None
otherwise.
The collection of type map underlying this TraversableLike
object.
The collection of type map underlying this TraversableLike
object.
By default this is implemented as the TraversableLike
object itself, but this can be overridden.
[use case] Checks if the other iterable collection contains the same elements in the same order as this map.
Checks if the other iterable collection contains the same elements in the same order as this map.
the collection to compare with.
true
, if both collections contain the same elements in the same order, false
otherwise.
Checks if the other iterable collection contains the same elements in the same order as this map.
Checks if the other iterable collection contains the same elements in the same order as this map.
Note: might return different results for different runs, unless the underlying collection type is ordered.
the type of the elements of collection that
.
the collection to compare with.
true
, if both collections contain the same elements in the same order, false
otherwise.
Produces a collection containing cummulative results of applying the operator going left to right.
Produces a collection containing cummulative results of applying the operator going left to right.
Note: might return different results for different runs, unless the underlying collection type is ordered.
the type of the elements in the resulting collection
the actual type of the resulting collection
the initial value
the binary operator applied to the intermediate result and the element
an implicit value of class CanBuildFrom
which determines the
result class That
from the current representation type Repr
and
and the new element type B
.
collection with intermediate results
Produces a collection containing cummulative results of applying the operator going right to left.
Produces a collection containing cummulative results of applying the operator going right to left.
Note: might return different results for different runs, unless the underlying collection type is ordered.
the type of the elements in the resulting collection
the actual type of the resulting collection
the initial value
the binary operator applied to the intermediate result and the element
an implicit value of class CanBuildFrom
which determines the
result class That
from the current representation type Repr
and
and the new element type B
.
collection with intermediate results
The size of this map.
Selects an interval of elements.
Selects an interval of elements.
Note: c.slice(from, to)
is equivalent to (but possibly more efficient than)
c.drop(from).take(to - from)
Note: might return different results for different runs, unless the underlying collection type is ordered.
the index of the first returned element in this map.
the index one past the last returned element in this map.
a map containing the elements starting at index from
and extending up to (but not including) index until
of this map.
Groups elements in fixed size blocks by passing a "sliding window" over them (as opposed to partitioning them, as is done in grouped.
Groups elements in fixed size blocks by passing a "sliding window" over them (as opposed to partitioning them, as is done in grouped.)
the number of elements per group
An iterator producing maps of size size
, except the
last will be truncated if the elements don't divide evenly.
Iterator#sliding
Splits this map into a prefix/suffix pair according to a predicate.
Splits this map into a prefix/suffix pair according to a predicate.
Note: c span p
is equivalent to (but possibly more efficient than)
(c takeWhile p, c dropWhile p)
, provided the evaluation of the predicate p
does not cause any side-effects.
Note: might return different results for different runs, unless the underlying collection type is ordered.
the test predicate
a pair consisting of the longest prefix of this map whose
elements all satisfy p
, and the rest of this map.
Splits this map into two at a given position.
Splits this map into two at a given position.
Note: c splitAt n
is equivalent to (but possibly more efficient than)
(c take n, c drop n)
.
Note: might return different results for different runs, unless the underlying collection type is ordered.
the position at which to split.
a pair of maps consisting of the first n
elements of this map, and the other elements.
Defines the prefix of this object's toString
representation.
Defines the prefix of this object's toString
representation.
a string representation which starts the result of toString
applied to this map.
Unless overridden in subclasses, the string prefix of every map is "Map"
.
[use case] Sums up the elements of this collection.
Sums up the elements of this collection.
the sum of all elements in this map of numbers of type Int
.
Instead of Int
, any other type T
with an implicit Numeric[T]
implementation
can be used as element type of the map and as result type of sum
.
Examples of such types are: Long
, Float
, Double
, BigInt
.
Sums up the elements of this collection.
Sums up the elements of this collection.
the result type of the +
operator.
an implicit parameter defining a set of numeric operations
which includes the +
operator to be used in forming the sum.
the sum of all elements of this map with respect to the +
operator in num
.
Selects all elements except the first.
Selects all elements except the first.
Note: might return different results for different runs, unless the underlying collection type is ordered.
a map consisting of all elements of this map except the first one.
Selects first n elements.
Selects first n elements.
Note: might return different results for different runs, unless the underlying collection type is ordered.
Tt number of elements to take from this map.
a map consisting only of the first n
elements of this map, or else the
whole map, if it has less than n
elements.
Selects last n elements.
Selects last n elements.
Note: might return different results for different runs, unless the underlying collection type is ordered.
the number of elements to take
a map consisting only of the last n
elements of this map, or else the
whole map, if it has less than n
elements.
Takes longest prefix of elements that satisfy a predicate.
Takes longest prefix of elements that satisfy a predicate.
Note: might return different results for different runs, unless the underlying collection type is ordered.
The predicate used to test elements.
the longest prefix of this map whose elements all satisfy
the predicate p
.
The underlying collection seen as an instance of Map
.
The underlying collection seen as an instance of Map
.
By default this is implemented as the current collection object itself,
but this can be overridden.
[use case] Converts this map to an array.
Converts this map to an array.
an array containing all elements of this map.
A ClassManifest
must be available for the element type of this map.
Converts this map to an array.
Converts this map to an array.
the type of the elements of the array. A ClassManifest
for this type must
be available.
an array containing all elements of this map.
Converts this map to a mutable buffer.
Converts this map to a mutable buffer.
a buffer containing all elements of this map.
A conversion from collections of type Repr
to Map
objects.
A conversion from collections of type Repr
to Map
objects.
By default this is implemented as just a cast, but this can be overridden.
Converts this map to an indexed sequence.
Converts this map to an indexed sequence.
an indexed sequence containing all elements of this map.
Converts this map to an iterable collection.
Converts this map to an iterable collection. Note that
the choice of target Iterable
is lazy in this default implementation
as this TraversableOnce
may be lazy and unevaluated (i.e. it may
be an iterator which is only traversable once).
an Iterable
containing all elements of this map.
Returns an Iterator over the elements in this map.
Returns an Iterator over the elements in this map. Will return the same Iterator if this instance is already an Iterator.
an Iterator containing all elements of this map.
Converts this map to a list.
Converts this map to a list.
a list containing all elements of this map.
Converts this map to a map.
Converts this map to a map. This method is unavailable unless the elements are members of Tuple2, each ((K, V)) becoming a key-value pair in the map. Duplicate keys will be overwritten by later keys: if this is an unordered collection, which key is in the resulting map is undefined.
a map containing all elements of this map.
Converts this map to a sequence.
Converts this map to a sequence.
a sequence containing all the elements of this map.
Converts this map to a set.
Converts this map to a set.
a set containing all elements of this map.
Converts this map to a stream.
Converts this map to a stream.
a stream containing all elements of this map.
Converts this map to a string.
Converts this map to a string.
a string representation of this collection. By default this
string consists of the stringPrefix
of this map,
followed by all elements separated by commas and enclosed in parentheses.
Converts this map to an unspecified Traversable.
Converts this map to an unspecified Traversable. Will return the same collection if this instance is already Traversable.
a Traversable containing all elements of this map.
[use case] Creates a new map obtained by updating this map with a given key/value pair.
Creates a new map obtained by updating this map with a given key/value pair.
the key
the value
A new map with the new key/value mapping added to this map.
Creates a new map obtained by updating this map with a given key/value pair.
Creates a new map obtained by updating this map with a given key/value pair.
the type of the added value
the key
the value
A new map with the new key/value mapping added to this map.
Collects all values of this map in an iterable collection.
Collects all values of this map in an iterable collection.
the values of this map as an iterable.
Creates an iterator for all values in this map.
Creates an iterator for all values in this map.
an iterator over all values that are associated with some key in this map.
Creates a non-strict view of a slice of this map.
Creates a non-strict view of a slice of this map.
Note: the difference between view
and slice
is that view
produces
a view of the current map, whereas slice
produces a new map.
Note: view(from, to)
is equivalent to view.slice(from, to)
Note: might return different results for different runs, unless the underlying collection type is ordered.
the index of the first element of the view
the index of the element following the view
a non-strict view of a slice of this map, starting at index from
and extending up to (but not including) index until
.
Creates a non-strict view of this map.
Creates a non-strict view of this map.
a non-strict view of this map.
Creates a non-strict filter of this map.
Creates a non-strict filter of this map.
Note: the difference between c filter p
and c withFilter p
is that
the former creates a new collection, whereas the latter only restricts
the domain of subsequent map
, flatMap
, foreach
, and withFilter
operations.
Note: might return different results for different runs, unless the underlying collection type is ordered.
the predicate used to test elements.
an object of class WithFilter
, which supports
map
, flatMap
, foreach
, and withFilter
operations.
All these operations apply to those elements of this map which
satisfy the predicate p
.
[use case] Returns a map formed from this map and another iterable collection by combining corresponding elements in pairs.
Returns a map formed from this map and another iterable collection by combining corresponding elements in pairs. If one of the two collections is longer than the other, its remaining elements are ignored.
the type of the second half of the returned pairs
The iterable providing the second half of each result pair
a new map containing pairs consisting of
corresponding elements of this map and that
. The length
of the returned collection is the minimum of the lengths of this map and that
.
Returns a map formed from this map and another iterable collection by combining corresponding elements in pairs.
Returns a map formed from this map and another iterable collection by combining corresponding elements in pairs. If one of the two collections is longer than the other, its remaining elements are ignored.
Note: might return different results for different runs, unless the underlying collection type is ordered.
the type of the first half of the returned pairs (this is always a supertype
of the collection's element type A
).
the type of the second half of the returned pairs
the class of the returned collection. Where possible, That
is
the same class as the current collection class Repr
, but this
depends on the element type (A1, B)
being admissible for that class,
which means that an implicit instance of type CanBuildFrom[Repr, (A1, B), That]
.
is found.
The iterable providing the second half of each result pair
an implicit value of class CanBuildFrom
which determines the
result class That
from the current representation type Repr
and the new element type (A1, B)
.
a new collection of type That
containing pairs consisting of
corresponding elements of this map and that
. The length
of the returned collection is the minimum of the lengths of this map and that
.
[use case] Returns a map formed from this map and another iterable collection by combining corresponding elements in pairs.
Returns a map formed from this map and another iterable collection by combining corresponding elements in pairs. If one of the two collections is shorter than the other, placeholder elements are used to extend the shorter collection to the length of the longer.
the type of the second half of the returned pairs
The iterable providing the second half of each result pair
the element to be used to fill up the result if this map is shorter than that
.
the element to be used to fill up the result if that
is shorter than this map.
a new map containing pairs consisting of
corresponding elements of this map and that
. The length
of the returned collection is the maximum of the lengths of this map and that
.
If this map is shorter than that
, thisElem
values are used to pad the result.
If that
is shorter than this map, thatElem
values are used to pad the result.
Returns a map formed from this map and another iterable collection by combining corresponding elements in pairs.
Returns a map formed from this map and another iterable collection by combining corresponding elements in pairs. If one of the two collections is shorter than the other, placeholder elements are used to extend the shorter collection to the length of the longer.
Note: might return different results for different runs, unless the underlying collection type is ordered.
the iterable providing the second half of each result pair
the element to be used to fill up the result if this map is shorter than that
.
the element to be used to fill up the result if that
is shorter than this map.
a new collection of type That
containing pairs consisting of
corresponding elements of this map and that
. The length
of the returned collection is the maximum of the lengths of this map and that
.
If this map is shorter than that
, thisElem
values are used to pad the result.
If that
is shorter than this map, thatElem
values are used to pad the result.
[use case] Zips this map with its indices.
Zips this map with its indices.
A new map containing pairs consisting of all elements of this
map paired with their index. Indices start at 0
.
@example
List("a", "b", "c").zipWithIndex = List(("a", 0), ("b", 1), ("c", 2))
Zips this map with its indices.
Zips this map with its indices.
Note: might return different results for different runs, unless the underlying collection type is ordered.
the type of the first half of the returned pairs (this is always a supertype
of the collection's element type A
).
the class of the returned collection. Where possible, That
is
the same class as the current collection class Repr
, but this
depends on the element type (A1, Int)
being admissible for that class,
which means that an implicit instance of type CanBuildFrom[Repr, (A1, Int), That]
.
is found.
A new collection of type That
containing pairs consisting of all elements of this
map paired with their index. Indices start at 0
.
A template trait for maps, which associate keys with values.
Implementation note: This trait provides most of the operations of a
Map
independently of its representation. It is typically inherited by concrete implementations of maps.To implement a concrete map, you need to provide implementations of the following methods:
If you wish that methods like
take
,drop
,filter
also return the same kind of map you should also override:It is also good idea to override methods
foreach
andsize
for efficiency.the type of the keys.
the type of associated values.
the type of the map itself.
version
2.8
since
2.8
authors:
Martin Odersky


JavaScript is disabled on your browser.
Skip navigation links
Overview
Package
Class
Tree
Deprecated
Index
Help
Prev Letter
Next Letter
Frames
No Frames
All Classes
A
B
C
D
F
G
H
I
J
K
L
M
N
O
P
R
S
T
U
V
W
X
Y
Z
P
PermissionActivity
- Class in
com.theif519.sakoverlay.Core.Activities
Created by Louis Jenkins
This activity is essentially called to obtain the CaptureScreenPermission (or whatever it's called) from the user.
PermissionActivity()
- Constructor for class com.theif519.sakoverlay.Core.Activities.
PermissionActivity
PermissionInfo
- Class in
com.theif519.sakoverlay.Core.POJO
Created by theif519 on 11/26/2015.
PermissionInfo(Intent, int)
- Constructor for class com.theif519.sakoverlay.POD.
PermissionInfo
prettyDuration(int)
- Method in class com.theif519.sakoverlay.Core.Async.
MediaThumbnailGenerator
prettyFileSize(long)
- Method in class com.theif519.sakoverlay.Core.Async.
MediaThumbnailGenerator
Converts size to human readable format.
prevX
- Variable in class com.theif519.sakoverlay.Core.Fragments.Floating.
FloatingFragment
prevY
- Variable in class com.theif519.sakoverlay.Core.Fragments.Floating.
FloatingFragment
publish(Object)
- Static method in class com.theif519.sakoverlay.Core.Rx.
RxBus
Publishes an event to any and all subscribers.
A
B
C
D
F
G
H
I
J
K
L
M
N
O
P
R
S
T
U
V
W
X
Y
Z
Skip navigation links
Overview
Package
Class
Tree
Deprecated
Index
Help
Prev Letter
Next Letter
Frames
No Frames
All Classes


Audiogram is a BBC News Labs prototype, based on original work by NPR's WNYC in New York, which converts audio into shareable video.
Take a look at some examples on Twitter.
It's currently experimetal, and may (probably will) break at some point. Please tell us when it does, so we can make it better. Similarly, we want your suggestions and feature requests! Tell us what you like and don't like about the tool, and how we could make it better, or a more seamless component of your existing workflows.
Please email<EMAIL_ADDRESS>the BBC developer on this project, with issues, suggestions, feedback, insights into your team's workflow, and offers of free cake.
To get started, select an input source above.


Preparation time
overnight
Cooking time
less than 10 mins
Serves
Serves 6
Dietary
Summer pudding is much easier to make than you think. Try our step-by-step video recipe for a perfect pudding.
Equipment and preparation: You'll need a 1 litre/2 pint pudding basin.
Place the fruit in a pan. Remove the stems from the redcurrants (if using) with a fork, pour the sugar over the fruit and stir gently to mix together.
If you have time, cover the pan with a tea towel or cling film and leave for 3-5 hours (or overnight) to get the juices running. Place the pan over a moderate heat and bring gently up to the boil.
While the fruit is simmering, cut the bread into thin slices and remove the crusts.
When the juices are beginning to flow, raise the heat slightly and simmer for about 2-3 minutes. Then turn off the heat and stir in the cassis or blackcurrant cordial.
Cut a round out of one slice of bread to fit the bottom of the bowl, then cut the remaining slices into triangular wedges.
Dip one side of the bread circle into the juices in the pan containing the fruit, then place the circle in the bottom of the pudding basin, juice-side down. Do the same with the bread triangles, dipping one side of the bread into the juices before placing them around the edge of the bowl, with the dipped side facing outwards. The tips of the bread triangles will be sticking up from the top of the bowl at this stage.
Once the bowl is completely lined with the juice-soaked bread (be sure to plug any gaps with small pieces of bread if necessary), spoon all of the fruit and its juices into the pudding basin. Trim the tips of bread from around the edge. Cover the top of the fruit with more wedges of bread. Place the pudding basin on a plate to collect any juices.
Find a saucer that fits neatly inside the bowl. Place it on top to cover the upper layer of bread, then weigh the saucer down with weights - bags of rice, tins of baked beans, or whatever comes to hand. Let it cool, then place in the fridge overnight.
The next day, remove the weights and the saucer. Run a thin blade around the edges, then invert the basin onto a shallow serving plate.
Turn the pudding out, cut into thick slices and serve the summer pudding with cream.


Jslet Generated by JSON And Commonjs by SPM3.6
Edit Data
Query Criteria
Master/Detail
ContextRule
lookupField
groupField
DBEditPanel


osmo_jupyter.plot package¶
Submodules¶
osmo_jupyter.plot.color_from_temperature module¶
-
osmo_jupyter.plot.color_from_temperature.
color_from_temperature
(temperature)¶ Basic color scale going from blue at the minimum temperature to red at the max temperature. Note: this corresponds to the behavior of the Bluered color scale implemented by plotly - when setting marker
color, use that instead. This can be used for line color.
osmo_jupyter.plot.do_calibration module¶
-
osmo_jupyter.plot.do_calibration.
calibration_error_plot
(predicted_do, actual_do, temperature, fit_title)¶ Plot showing the error in predicted DO as distributed over DO and temperature
-
osmo_jupyter.plot.do_calibration.
plot_calibration
(sensor_data: pandas.core.frame.DataFrame, fit_params: List[float], title: str, estimate_do_fn: Callable, estimate_optical_reading_fn: Callable)¶ Visualize sensor in the context of a curve fit and fit parameters, including numerical measures of fit quality.
- Args:
- sensor_data: pandas DataFrame of observations. should have the following columns:
timestamp, Temperature (C), DO (% sat), SR reading
fit_params: Fit parameters for the curve function connecting optical reading with DO and temperature title: Title of fit, to use in plots estimate_do_fn: Function of ((optical reading, temperature), *fit_params) which provides a DO estimate in % sat estimate_optical_reading_fn:
Function of ((DO, temperature), *fit_params) which provides an optical reading estimate
- Returns:
None. Produces plots and printed data frame
osmo_jupyter.plot.heatmap module¶
-
osmo_jupyter.plot.heatmap.
cut_array2d
(array, block_shape)¶ - Cuts up an array into blocks of shape block_shape. If block_shape doesn’t factor perfectly into the
shape of the array, drops data from the right and bottom edges of the input array. Heavily, heavily adapted from https://stackoverflow.com/a/17385776/1701416
- Args:
array: a 2D numpy array block_shape: a 2-tuple. The shape of the blocks you want the array to be cut into
- Return:
- (block_centers, blocks) tuple where
block_centers: a 1D array of 2-tuple coordinates for the centers of the sliced blocks blocks: a 1D array of blocks of shape block_shape
-
osmo_jupyter.plot.heatmap.
display_heatmap
(array, display_decimals=2, title='Heatmap')¶ Builds the heatmap figure from provided array
- Args:
array: A 2D numpy array to render as a heatmap display_decimals: Optional (default=2). the number of decimals to round to in the annotation title: Optional (default=’Heatmap’)
- Returns:
A heatmap Figure. Can be displayed in a jupyter notebook using the display() function.
-
osmo_jupyter.plot.heatmap.
get_block_means_2d
(block_centers, blocks, averaging_function=<function mean>)¶ Given 1D arrays of block_centers and blocks, construct a 2D array of block means.
- Args:
block_centers: a 1D array of 2-tuple coordinates for the centers of the sliced blocks blocks: a 1D array of 2D blocks averaging_function: Optional (default=np.mean). Function to use to get the average of each block (a 2D array)
- Returns:
a 2D array of block means
-
osmo_jupyter.plot.heatmap.
heatmapify
(array, averaging_function=<function mean>, block_shape=(50, 50), display_decimals=2, title='Heatmap')¶ - Constructs a heatmap from a 2D array. The heatmap is created by slicing the array into blocks the size of
block_shape, and then averaging each block.
- Args:
- array: A 2D numpy array to render as a heatmap. e.g. a single channel of an RGB image:
array = image[:, :, channel] # channel is 0, 1, or 2, for r, g, b respectively
averaging_function: Optional (default=np.mean). Function to use to get the average of each block (a 2D array) block_shape: Optional (default=(50,50)). The shape of block to group by and average over to create the heatmap display_decimals: Optional (default=2). The number of decimals to round to in the annotation title: Optional (default=’Heatmap’).
- Returns:
A heatmap Figure. Can be displayed in a jupyter notebook using the display() function.
osmo_jupyter.plot.scatter module¶
-
osmo_jupyter.plot.scatter.
get_layout_with_annotations
(x_axis_title='Time', y_axis_title='', colors_on_separate_axes=False, events=None, **additional_layout_kwargs)¶ Get a go.Layout instance prepared for our standard graphing needs
Notes re. our standard layout: * The primary Y axis (y0) is reserved for annotations. This is done to guarantee that annotations show * If colors are on separate axes, they will be on the next consecutive axes, otherwise they will be on yaxis 2 * You can use additional axes for plotting other things by passing in additional params
- Args:
x_axis_title: title to use for X axis, default ‘Time’ y_axis_title: title to use for Y axis where colors are plotted. Required if colors_on_separate_axes is False.
If colors_on_separate_axes is True, it will be used as a suffix for the y axis titles “r”, “g”, and “b”
colors_on_separate_axes: whether colors (r,g and b) should be displayed on separate Y axes events: dictionary of {“annotation”: x_axis_value} which will be used to annotate the chart additional_layout_kwargs: Any additional arguments will be passed to go.Layout. These can, for instance,
be the result of _axis_kwargs() to add support for graphing more items. Valid options are documented at https://plot.ly/python/reference/#layout
-
osmo_jupyter.plot.scatter.
get_rgb_scatters
(rgb_df, x_column=None, colors_on_separate_axes=False, dataset_name=None, marker_overrides=None, scatter_overrides=None, colors_to_include=['r', 'g', 'b'])¶ get go.Scatter instances for each ‘rgb’ color in the input DataFrame
example usage: >>> import pandas as pd >>> import plotly.graph_objs as go >>> rgb_df = pd.DataFrame({‘r’: [1,2,3], ‘g’: [2,3,4], ‘b’: [3,4,5], ‘x_axis’: [0,1,2]}) >>> go.FigureWidget(rgb_scatters(rgb_df, x_column=’x_axis’)) [result is a plot with your three channels]
- Args:
rgb_df: pandas.DataFrame instance with ‘r’, ‘g’, and ‘b’ columns, and a column for the X axis value x_column: Optional, name of the column in rgb_df to use for the X axis values. if None, we’ll use the index colors_on_separate_axes: Optional, if True, will plot each color series on a separate axis dataset_name: Optional, string to use in legend labels marker_overrides: Optional, dict of additional arguments for go.Marker.
Valid options are documented at https://plot.ly/python/reference/#scatter-marker
- scatter_overrides: Optional, dict of additional_arguments for go.Scatter.
Valid options are documented at https://plot.ly/python/reference/#scatter
- colors_to_include: Optional list of color letters to include - provide if you don’t want all the colors.
Should be a subset of COLOR_CHANNELS.
- Returns:
list of go.Scatter objects, one each for r, g, and b or colors_to_include if provided
-
osmo_jupyter.plot.scatter.
get_scatter
(y_values, x_values=None, dataset_name=None, y_axis_number=1, marker_overrides=None, scatter_overrides=None)¶ Quick way to get a go.Scatter to put on your plot with some conveniences.
- Args:
y_values: iterable of Y values can be a pandas Series or whatever x_values: Optional, X values to go along with those. If not provided, y_values is expected to be a Series and
we’ll use the index from it
- dataset_name: Optional, name to put in the chart legend. If not provided, y_values is expected to be a Series
and we’ll use its name
- y_axis_number: Optional, Y-axis number. Defaults to the primary (1) Y axis. Note that axes 2-4 are used for
RGB values.
- marker_overrides: Optional, dict of go.Scatter.Marker attributes to override marker style.
Valid options are documented at https://plot.ly/python/reference/#scatter-marker
- scatter_overrides: Optional, dict of go.Scatter attributes to override the Scatter.
Valid options are documented at https://plot.ly/python/reference/#scatter


df_opt_birthwt.Rd
Dataset from Baystate Medical Center in Springfield, Massachusetts (Hosmer et. al. 1998) low: indicator of birth weight less than 2.5 kg. age: mother's age in years. lwt: mother's weight in pounds at last menstrual period. race: mother's race (1 = white, 2 = black, 3 = other). smoke: smoking status during pregnancy. ptl: number of previous premature labours. ht: history of hypertension. ui: presence of uterine irritability. ftv: number of physician visits during the first trimester. bwt: birth weight in grams.
data(df_opt_birthwt)
csv
https://onlinelibrary.wiley.com/doi/book/10.1002/9781118548387
HOSMER, D.W., HOSMER, T., LE CESSIE, S. and LEMESHOW, S. (1997), A COMPARISON OF GOODNESS‐OF‐FIT TESTS FOR THE LOGISTIC REGRESSION MODEL. Statist. Med., 16: 965-980. doi:10.1002/(SICI)1097-0258(19970515)16:9<965::AID-SIM509>3.0.CO;2-O
#> Index low age lwt race smoke ptl ht ui ftv bwt #> 1 85 0 19 182 2 0 0 0 1 0 2523 #> 2 86 0 33 155 3 0 0 0 0 3 2551 #> 3 87 0 20 105 1 1 0 0 0 1 2557 #> 4 88 0 21 108 1 1 0 0 1 2 2594 #> 5 89 0 18 107 1 1 0 0 1 0 2600 #> 6 91 0 21 124 3 0 0 0 0 0 2622 #> 7 92 0 22 118 1 0 0 0 0 1 2637 #> 8 93 0 17 103 3 0 0 0 0 1 2637 #> 9 94 0 29 123 1 1 0 0 0 1 2663 #> 10 95 0 26 113 1 1 0 0 0 0 2665


Sonic The Hedgehog: Fans hail redesign as ‘greatest glow up of 2019’
by By Press AssociationSonic The Hedgehog’s makeover was hailed a success by fans as a new trailer for the upcoming movie was released.
Fans reacted with horror when the original trailer for the film was unveiled in April, criticising the design of the title character for his human-like face, big teeth and disproportionate legs.
Now Sonic, star of a popular series of Sega video games in the 1990s, has had a redo with a design closer to that of the original character – and fans are relieved.
The criticism of the original trailer sent designers and animators back to the drawing board to completely remodel the look of the beloved blue hedgehog – work which caused the release date of the movie to be pushed back until next year.
Fans were impressed with the transformation, or glow up, that Sonic had undergone for the movie, in which he is voiced by Ben Schwartz.
Many people praised the work of the animators who worked to change the design.
Now people are excited to see the movie, which also stars Jim Carrey as Dr Robotnik and Westworld’s James Marsden as Tom Wachowski – although some still had some doubts about other aspects of the trailer.
Sonic The Hedgehog is due for release on Valentine’s Day 2020.


This interface allows you to create status updates to the designated place.
This is the activity from the current place above.
{{summary}}


Appearance
The lid is purple with pink splashes, a logo appeared next to the button - the letter "M". The lower part remained unchanged. The number of mirrors has also increased.


{{ CSS.push('less/calls.less') }} {{ CSS.render('css/calls.min.css') }}
Use this option to call control of a chamber for one party, before that party has 50%+1 of the seats.
If a party has already won 50%+1 of the seats, this setting will do nothing.
{% if chamber_call_override %} {% else %} {% endif %}{{ results[0].precinctsreportingpct|percent }} of precincts reporting ({{ results[0].precinctsreporting|comma }} of {{ results[0].precinctstotal|comma }})
| Candidate | Vote count | NPR Winner | AP Winner | Call for NPR | {% for result in results[:5] %}
|---|---|---|---|---|
| {% if result.first %} {{ result.first }} {% endif %} {{ result.last }} | {{ result.votecount|comma }} | |||
| {{ results[5:]|length }} more candidate(s) not shown |


Try out our Premium Member services: Virtual Legal Assistant, Query Alert Service and an ad-free experience. Free for one month and pay only if you like it.
* IN THE HIGH COURT OF DELHI AT NEW DELHI % Order reserved on : 10.04.2013 Order pronounced on: 16.04.2013 + W.P.(C) 9337/2009 SOCIETY FOR PROTECTION OF CULTURE HERITAGE ENVIRONMENT TRADITIONS AND PROMOTIONS OF NATIONAL AWARENESS ......Petitioner Versus UOI & ORS. ......Respondents + W.P.(C) 12719/2009 INDIAN SPINAL INJURIES HOSPITAL .....Petitioner Versus UOI & ORS. ......Respondents + W.P.(C) 13675/2009 BIJWASAN GRAM VIKAS SAMITI & ORS. .....Petitioners Versus UOI & ORS. ......Respondents Through : Mr. Sanjeev Anand, Ms. Renu and Mr. Anubha Surana, Advs. for petitioners in W.P.(C) 9337/2009 Ms Anjana Gosain and Mr T. Mitra, Advs. for AAI in W.P.(C) 9337/2009 and for AAI in W.P.(C) 12719/2009 Ms. Maneesha Dhir and Ms Mithu Jain Advs. for petitioners in W.P.(C) 12719/2009 W.P(C) Nos. 9337/2009, 12719/2009 & 13675/2009 Page 1 of 8 Mr Jayant Bhushan, Sr. Adv. with Mr Atul Sharma, Mr Milanka Chaudhury, Mr Abhishek Sharma, Mr. Amit Ojha and Mr. Manu Sahni, Advs for DIAL Mr. Darpan Wadhwa, Adv. for NCT of Delhi in W.P.(C) 13675/2009 CORAM: HON'BLE THE CHIEF JUSTICE HON'BLE MR. JUSTICE V.K. JAIN V.K. JAIN, J.
1. Section 3 of the Environment (Protection) Act, 1986 empowers the Central Government to take such measures as it deems necessary or expedient for the purpose of protecting and improving the quality of the environment and preventing controlling and abating environmental pollution. Section 6 of the said Act empowers the Central Government, inter alia, to make rules providing for the maximum allowable limits of concentration of various environmental pollutants (including noise) for different areas. Section 25 of the said Act empowers the Central Government to make rules for carrying out the purposes of this Act. Rule 5 of the Environment (Protection) Rules, provides that the Central Government may take into consideration, inter alia, the maximum allowable limits of concentration of various environment pollutants (including noise) for an area, while prohibiting or restricting the location of industries and carrying on of processes and operations in different areas. In exercise of the aforesaid powers, the Central Government framed rules called the Noise Pollution (Regulation and Control) Rules, W.P(C) Nos. 9337/2009, 12719/2009 & 13675/2009 Page 2 of 8 2000. Rule 3(1) of the said Rules provides that the ambient air quality standards in respect of noise for different areas zones shall be such, as is specified in the Schedule annexed to these rules. Clause (3) of the said Rules provides that the State Government shall take measures for abatement of noise, including the noise emanating from vehicular movements and ensure that the existing noise levels do not exceed the ambient air quality standards specified under these rules. Rule 4 (1) provides that the noise levels in any area/ zone shall not exceed the ambient air quality standards in respect of noise as specified in the Schedule.
As per the Schedule to the said Rules, the following are the ambient air quality standards in respect of noise:
Area Code Category of Area/Zone Limits in dB(A) Leq* Day Time Night Time (A) Industrial Area 75 70 (B) Commercial Area 65 55 (C) Residential Area 55 45 (D) Silence Zone 50 40 Note.- 1. Day time shall mean from 6.00 am to 10.00 pm 2. Night time shall mean form 10.00 pm to 6.00 am.
3. Silence Zone is an area comprising not less than 100 metres around hospitals, educational institutions, courts, religious places or any other area which is declared as such by the competent authority.
W.P(C) Nos. 9337/2009, 12719/2009 & 13675/2009 Page 3 of 84. Mixed categories of areas may be declared as one of the four above mentioned categories by the competent authority.
*dB(A) Leq denotes the time weighted average of the level of sound in decibels on Scale A which is relatable to human hearing. A "decibel" is a unit in which noise is measured.
"A", in dB(A) Leq, denotes the frequency weighting in the measurement of noise and corresponds to frequency response characteristics of the human ear.
Leq: It is energy mean of the noise level over a specified period.
2. Vasant Kunj is a residential colony developed by the Delhi Development Authority stated to be having about 20,000 residential flats inhabited by more than 60,000 persons. The said area is stated to have more than 20 schools besides Jawaharlal Nehru University and various institutions including Indian Spinal Injury Centre, Fortis Hospital and Apollo Hospital Centre. The area also has a number of shopping malls. The case of the Society for Protection of Cultural Heritage Environment Traditions and Promotions of National Awareness, the petitioner in W.P(C) No.9337/2009 is that though the noise level in the area of Vasant Kunj is roughly between 74 to 84 dB(A) due to the noise created by over flying of aircrafts and as per the report submitted by the Chairman, Airport Association, the noise level touches up to 99 decibels at the time the aircraft approaches for landing and crosses 98 decibels at the lateral stage. This is also the case of the petitioner that the noise pollutants created by aircrafts is causing noise and affecting the health of the residents of the Vasant Kunj and nearby area, thereby violating their fundamental rights to lives and liberty guaranteed under Article 21 of the W.P(C) Nos. 9337/2009, 12719/2009 & 13675/2009 Page 4 of 8 Constitution, besides, contravening the Noise Pollution (Regulation and Control) Rules, 2000. The petitioner has accordingly sought, inter alia, directions to the respondents to stop flying of Aircrafts over these areas. The petitioners are also seeking direction to the respondent to immediately provide noise barriers along with the runways at the IGI Airport. They have also sought quashing of granting environment clearance for construction of 3rd runway at IGI Airport, New Delhi.
3. W.P(C) No.12719/2009 has been filed by Indian Spinal Injuries Hospital which is a hospital situated in Vasant Kunj area. The case of the petitioner is that the sound emitted by the aircrafts flying over the hospital is in the range of 75 dB(A) to 84 dB(A) which is clearly beyond the prescribed limits, as a result of which the in-house patients of the hospital are constantly suffering from noise pollution caused by the low flying of the aircrafts. The prayer made in this petition is also identical to the prayers made in W.P(C) No.9337/2009.
4. W.P(C) No.13675/2009 has been filed by Bijwasan Gram Vikas Samiti and others on similar allegations. Bijwasan also is an area nearby the IGI Airport. The prayer made in this petition is to direct the respondents to take necessary measures to mitigate the noise pollution caused by the aircrafts.
5. The National Green Tribunal Act, 2010 came into force on 18.10.2010. The Act provides for establishment of a Tribunal to exercise the jurisdiction, powers and authority conferred on such Tribunal under the said Act. Section 14 of the Act, to the extent it is relevant, provides that the Tribunal shall have the jurisdiction over all civil cases where a W.P(C) Nos. 9337/2009, 12719/2009 & 13675/2009 Page 5 of 8 substantial question relating to environment, including enforcement of any legal right relating to environment, is involved and such question arises out of the implementation of the enactments specified in Schedule I. Sub section (2) of the said Section provides that Tribunal shall hear the disputes arising from the questions referred to in sub-section (1) settle such disputes and pass order thereon. Section 15(1) of the said Act provides that the Tribunal may, by an order, provide, (a) relief and compensation to the victims of pollution and other environmental damage arising under the enactments specified in the Schedule 1, including accident occurring while handling any hazardous substance, (b) for restitution of property damaged and (c) for restitution of the environment for such area or areas, as the Tribunal may think fit.
Schedule-I of the said Act includes the Environment (Protection) Act, 1986 as well as the Air (Prevention and Control of Pollution) Act, 1981. The expression "air pollutant" has been defined in the later Act to mean any solid, liquid or gaseous substance (including noise) present in the atmosphere in such concentration as may be or tend to be injuries to human beings or other living creatures or plants or property or environment. „Air pollution‟ has been defined in Section 2(b) to mean the presence in the atmosphere of any air pollutant.
6. It would be seen from a perusal of Section 14 of the National Green Tribunal Act, 2010 that before a matter can be brought to the Tribunal, it should fulfill two requirements. Firstly, it should involve a substantial question relating to environment and secondly, such question W.P(C) Nos. 9337/2009, 12719/2009 & 13675/2009 Page 6 of 8 should arise out of the implementation of one or more of the Acts specified in Schedule-I to the Act.
7. Considering the provisions of Environment Protection Act, 1986, The Environment Protection Rules, 1986 and the Noise Pollution (Regulation and Control) Rules, 2000 as also the definition of noise pollutants given in the Air (Prevention and Control of Pollution) Act, 1981, it can hardly be disputed that these petitions involve a substantial question relating to environment including enforcement of legal rights relating to environment and such questions arise out of the implementation particularly of the Environment (Protection) Act, 1986. If the noise level in Vasant Kunj, Bijwasan and other areas in the vicinity of Terminal-III of IGI Airport exceeds the limits laid down in the Schedule, that would be substantial question relating to environment and also amount to violation of the provisions of Environment (Protection) Act, 1986. Thus, these petitions fulfill the twin requirements of Section 14 of the National Green Tribunal Act, 2010. Had these petitions been filed after constitution of National Green Tribunal, the said Tribunal would have jurisdiction to hear and decide these petitions and pass appropriate orders thereon. The Tribunal would have also the power to provide one or more reliefs envisaged in Section 15 of the National Green Tribunal Act, 2010.
8. Vide its order dated 9.8.2012 passed in IA No.62-63/2011 in Civil Appeal No.3187-88/1988, the Supreme Court, inter alia, directed as under:
W.P(C) Nos. 9337/2009, 12719/2009 & 13675/2009 Page 7 of 8"39. We find it imperative to place on record a caution for consideration of the courts of competent jurisdiction that the cases filed and pending prior to coming into force of the NGT Act, involving questions of environment laws and/or relating to any of the seven statutes specified in Schedule I of the NGT Act, should also be dealt with by the specialized tribunal, that is the NGT, created under the provisions of the NGT Act. The Courts may be well advised to direct transfer of such cases to the NGT in its discretion, as it will be in the fitness of administration of justice."
9. Considering the above referred decision of the Supreme Court and the issues involved in these petitions, as discussed hereinbefore, we are of the view that these petitions should be transferred to the National Green Tribunal. In our opinion, such an order would only subserve the interest of justice. We ordered accordingly. Registry is directed to send the entire record of these petitions to the Registrar of National Green Tribunal within one week.
V.K.JAIN, J CHIEF JUSTICE APRIL 16, 2013 rd W.P(C) Nos. 9337/2009, 12719/2009 & 13675/2009 Page 8 of 8


Development and Deployment Model¶
The development and deployment processes leverages Docker to guaruntee quality releases.
Development¶
For development, install Docker and Docker Compose. We use Docker Compose to get a full Nginx-Flask-UWSGI environment running, to ensure that traffic to the application always operates the same. Deployment is critical with Flask applications as you must have a WSGI server like GUnicorn or UWSGI in order to prevent yourself from exposing the debug mode directly. Docker Compose allows us to emulate real deployments and guaruntee the integrity of deployments on release.
To run the release environment, simply invoke the build
arg to up
from the root of the project:
docker-compose up --build
Deployment¶
Deployment is just as easy, all you need is to deploy the image itself. Just connect Dockerhub to GitHub and configure it to build image on push.
Once Dockerhub has built the image, you can use it from any instance with:
docker pull manistal/xlate:latest


{{ partial "head.html" . }}
{{ partial "header.html" (dict "hero" "homepage" "baseUrl" ($.Param " baseURL ") "page" .) }}HTTP downloads files from one computer at a time instead of getting pieces from multiple computers simultaneously. Peer-to-peer IPFS saves big on bandwidth — up to 60% for video — making it possible to efficiently distribute high volumes of data without duplication.
The average lifespan of a web page is 100 days before it's gone forever. It's not good enough for the primary medium of our era to be this fragile. IPFS keeps every version of your files and makes it simple to set up resilient networks for mirroring data.
The Internet has turbocharged innovation by being one of the great equalizers in human history — but increasing consolidation of control threatens that progress. IPFS stays true to the original vision of an open, flat web by delivering technology to make that vision a reality.
IPFS powers the creation of diversely resilient networks that enable persistent availability — with or without Internet backbone connectivity. This means better connectivity for the developing world, during natural disasters, or just when you're on flaky coffee shop wi-fi.
IPFS provides deduplication, high performance, and clustered persistence — empowering you to store the world's information for future generations.
Providing large amounts of data to users? IPFS offers secure, peer-to-peer content delivery — an approach that could save you millions in bandwidth costs.
If you're working with or distributing large data sets, IPFS can help provide fast performance and decentralized archiving.
High-latency networks are a big barrier for those with poor internet infrastructure. IPFS provides resilient access to data independent of latency or backbone connectivity.
With IPFS, you can address large amounts of data and put immutable, permanent links in transactions — timestamping and securing content without having to put the data itself on-chain.
IPFS brings the freedom and independent spirit of the web in full force — and can help you deliver your content at a much lower cost.


Preston's Walton le Dale Park and Ride introduces late services in run up to Christmas
by Megan TitleyPreston's Walton le Dale Park and Ride is introducing late services in the run up to Christmas.
The park and ride will be open every day throughout December, including Sundays, to help shoppers avoid the stress of city centre parking in the weeks before the big day.
Late night services for Christmas shopping will run every Wednesday and Thursday, starting on December 4, with the last bus from the city leaving Jacson Street at 9pm.
The late night service will also operate on Friday 20, Saturday 21 and Monday 23.
On Sundays, services from the Park and Ride will start at 10am, with the last bus from Preston leaving Jacson Street at 5.38pm.
Services will operate as normal from Monday to Saturday, with services from the Park and Ride starting at 7am, and the last bus from Preston leaving Jacson Street at 7:30pm.
This year there will also be a special late night opening on Saturday, November 23 for the Christmas Lights Switch On.
Including free parking, the price of an adult return fare is £1.60 with a child return costing 80p. Family and group tickets are also available.
To find out more about Park and Ride services over Christmas and the New Year, visit www.lancashire.gov.uk and search 'Park and Ride'.
The Park and Ride will not run on Christmas Day and Boxing Day.


Building mirage-www
This assumes that you’ve followed the Hello World instructions from earlier and are now familiar with the basic console, block device and networking configurations from the mirage-skeleton repository. To build the live MirageOS website, we’ll need several device drivers: two block devices for the static HTML content and the templates, and a network device to actually serve the traffic.
First, clone the website source code:
$ git clone git://github.com/mirage/mirage-www
$ cd mirage-www/src
$ cat config.ml
This config.ml
is more complex to reflect all the different ways we want to
statically build the website, but it also does a lot more! We’ll walk through it
step by step.
Building a Unix version
In order to configure the unikernel, we can use the mirage tool. To see all the available options:
cd src
mirage configure --help
Alternatively, You can get a quick overview of all the options (and their current value):
mirage describe
A Unix development workflow
For editing content and generally working with the website on a day-to-day basis, we simply compile it using kernel sockets and a pass-through filesystem. This is pretty similar a conventional web server, and means you can edit content using your favourite editor (though you must restart the website binary to make edits visible).
First, if you wish to build the site to present the site statistics (garbage collection, etc) data, build the JavaScript:
make prepare
Then configure and build the website itself:
$ cd src
$ mirage configure -t unix --kv_ro crunch --net socket
$ make
Finally, run the website application:
$ sudo ./mir-www
The website will now be available on http://localhost/
.
Building the direct networking version
Now you can build the Unix unikernel using the direct stack, via a similar
procedure to the hello world examples. As before,
Mirage will configure the stack to use the
tap0 interface with an address
of <IP_ADDRESS>/<IP_ADDRESS>
. Verify that you have an existing tap0
interface by reviewing $ sudo ip link show
; if you do not,
load the tuntap kernel module ($ sudo modprobe tun
)
and create a tap0
interface owned by root ($ sudo tunctl
). Bring tap0
up
using $ sudo ifconfig tap0 <IP_ADDRESS> up
, then:
$ cd src
$ mirage configure -t unix --net direct
$ make
$ sudo ./mir-www
You should now be able to ping the unikernel’s interface:
$ ping <IP_ADDRESS>
If you see ping responses, then you are now communicating with the MirageOS
unikernel via the OCaml TCP/IP stack! Point your web browser at
http://<IP_ADDRESS>
and you should be able to surf this website too.
Serving the site from a FAT filesystem instead
This site won’t quite compile to Xen yet. Despite doing all networking via an
OCaml TCP/IP stack, we still have a dependency on the Unix filesystem for our
files. MirageOS provides a FAT filesystem
which we’ll use as an alternative. Our new config.ml
will now contain this:
The FAT filesystem needs to be installed onto a block device, which we assign to a Unix file. The driver for this is provided via mmap in the mirage/mirage-block-unix module.
Now build the FAT version of the website. The config.ml
supplied in the real
mirage-www
repository uses an environment variable to switch to these
variables, so we can quickly try it as follows.
$ cd src
$ mirage configure -t unix --kv_ro fat
$ make
$ sudo ./mir-www & sudo ifconfig tap0 <IP_ADDRESS> <IP_ADDRESS> && fg
The make-fat_*-images.sh
script uses the fat
command-line helper installed by
the ocaml-fat
package to build the FAT block image for you. If you now access
the website, it is serving the traffic straight from the FAT image you just
created, without requiring a Unix filesystem at all!
You can inspect the resulting FAT images for yourself by using the fat
command
line tool, and the generated scripts.
$ file fat_block1.img
fat1.img: x86 boot sector, code offset 0x0, OEM-ID "ocamlfat",
sectors/cluster 4, FAT 1, root entries 512, Media descriptor 0xf8,
sectors/FAT 2, sectors 1728 (volumes > 32 MB) , dos < 4.0 BootSector (0x0)
$ fat list fat_block1.img
/wiki (DIR)(1856 bytes)
/wiki/xen-synthesize-virtual-disk.md (FILE)(8082 bytes)
/wiki/xen-suspend.md (FILE)(14120 bytes)
/wiki/xen-events.md (FILE)(10921 bytes)
/wiki/xen-boot.md (FILE)(5244 bytes)
/wiki/weekly (DIR)(768 bytes)
(The details of the file listing may vary if, for example, new posts have been added to the site recently.)
Building a Xen kernel
We’re now ready to build a Xen kernel. This can use eithr FAT or a builtin crunch (to avoid the need for an external block device). The latter is the default, for simplicity’s sake.
$ cd src
$ mirage configure -t xen
$ make
This will build a static kernel that uses the ocaml-crunch
tool to convert the
static website files into an OCaml module that is linked directly into the
image. While it of course will not work for very large websites, it’s just fine
for this website (or for configuration files that will never be very large). The
advantage of this mode is that you don’t need to worry about configuring any
external block devices for your VM, and boot times are much faster as a result.
You can now boot the mir-www.xen
kernel using sudo xl create -c www.xl
–
don’t forget to edit www.xl
to supply a VIF first though!
Modifying networking to use DHCP or static IP
Chances are that the Xen kernel you just built doesn’t have a useful IP address,
since it was hardcoded to <IP_ADDRESS>
. You can modify the HTTP driver to give it
a static IP address, as the
live deployment script
does.
We’ve shown you the very low-levels of the configuration system in MirageOS here. While it’s not instantly user-friendly, it’s an extremely powerful way of assembling your own components for your unikernel for whatever specialised unikernels you want to build.
We’ll talk about the deployment scripts that run the live site in the next article.


To the Campus Community,
I am pleased to announce that the CUNY Board of Trustees has approved the appointment of Hope Berte as CSI’s Vice President for Campus Planning, Facilities Management and Operations. I want to thank Provost Michael Parrish for chairing the search committee and all of the committee members for their hard work.
Ms. Berte has been a dedicated and valuable member of the College of Staten Island since April 2006. She has consistently received roles of increased responsibility, as evidenced through her career progression at CSI having served as the Associate Director for Human Resources, the Director of Human Resources, the Executive Director Human Resources & Labor Designee, the Deputy to the President/Chief of Staff and since July 2018, the Interim Vice President for Campus Planning, Facilities Management and Operations. Ms. Berte holds a Master of Science in Business Management and Leadership from CUNY School of Professional Studies, and a Bachelor of Science in Psychology from Brooklyn College
The appointment of Ms. Berte as Vice President for Campus Planning, Facilities Management and Operations will ensure that the College of Staten Island continues to have the critical leadership and oversight of the essential operations of the College and continue to focus on making the College a destination campus.
Please join me in congratulating Hope.
Sincerely,
William J. Fritz President


| 822 | (A) | thay tournede to thaire tentis witħ the tene that thay hade |
| 826 | (C) | ¶ They turnedde to her tentes . with tene þat þey hadde |
| 819 | (D) | Turnyd toward her tentis wiþ tene þat þei had |
| 795 | (E) | & turned to his tentys . witħ teene þat thei hadde |
| (Ex) | ---- no text ---- | |
| 843 | (L) | Tyen to here tentis myd tene þat þey hadde |
| 766 | (P) | Tyght is þaire tentis with tene þat þai had |
| 804 | (U) | Turned to her tentes / witħ tene that thei had |
| (V) | ---- no text ---- |