THE OLD LADY WHO WALKED IN THE SEA A film review by James Berardinelli Copyright 1995 James Berardinelli
RATING (0 TO 10): 7.0
France, 1991 U.S. Availability: 1995 (limited) Running Length: 1:35 MPAA Classification: No MPAA Rating (Profanity, sex, nudity) Theatrical Aspect Ratio: 1.85:1
Cast: Jeanne Moreau, Michel Serrault, Luc Thuillier, Geraldine Danon Director: Laurent Heynemann Screenplay: Dominique Roulet from the novel by San Antonio Cinematography: Robert Alazraki Music: Philippe Sarde U.S. Distributor: CFP Distribution Inc. In French with subtitles
Now in her sixties, Jeanne Moreau is no longer the sultry, beautiful woman who attained international notice through Louis Malle's 1959 LES AMANTS, but she can still act circles around performers half her age. As Lady M, the title character and centerpiece of Laurent Heynemann's THE OLD LADY WHO WALKED IN THE SEA, Moreau is a force to be reckoned with. Her presence provides a solid point of focus whenever the plot becomes murky or convoluted.
Lady M and her companion, an ex-lover named Pompilius (Michel Serrault), are spending a "working vacation" in Guadeloupe. Consummate con artists, the two are always in the process of pulling off some high risk, high reward scheme involving blackmail, deception, or theft. While Lady M is taking her morning walk in the sea (for her arthritis), she becomes acquainted with a young stud, Lambert (Luc Thuillier), who gets her attention by stealing her ring. She is impressed with Lambert's technique (among other things), and decides to take him on as her protege. Under her guidance and the reluctant tutelage of Pompilius (who views him as a rival), Lambert becomes a key participant in a scam to steal a maharaja's diamond-and-emerald-encrusted diadem.
Admittedly, the story isn't all that original, but the character interaction is masterful. The barbed verbal sparring between Lady M and Pompilius is a delight, as both of these veteran vocabulary duelists dig deep to come up with new appellations for each other. Some of the best include "My puss-filled raven", "My dime-store diplomat", "My tender buttered trollop", "My rotting old ramrod", and "My toothless comb." And those are only the ones suitable for print. The multi-layered dynamic between these two good friends is the glue that holds THE OLD LADY together.
There are elements of the film that don't work. Chief of these is a largely-superfluous romance between Lambert and a young woman (Geraldine Danon). Neither of the actors is all that impressive, and when Moreau isn't sharing the screen with them, things start to drag. THE OLD LADY also suffers from a bookend problem--that is to say, it opens and closes weakly. The middle section is by far the strongest, with Moreau in full bloom, Serrault in full bluster, and the banter zipping back and forth between them.
Beneath all the stinging dialogue, THE OLD LADY uses its trio of grifters to examine various questions about love, sex, passion, and friendship. The deepest, most lasting relationships that develop throughout the course of the movie don't involve sex. The film is more about intimacy than physicality, and how the two don't necessarily go together. Lady M claims to have had 2017 lovers, but her passion for crime has outlived her passion for men... or has it?
Released in France in 1991, this movie has taken four years to reach the United States, primarily because it never acquired a major distributor. (Currently, there are only a handful of available prints.) As far as imported fare goes, there's nothing astounding about THE OLD LADY, but it is a chance to view another fine performance by France's "Grande Dame" of film.
- James Berardinelli<EMAIL_ADDRESS>The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


About me
Hi, my name is Nikola Jović. I finished "Gimnazija u Obrenovcu" high school. I am self taught Unity C# Developer and I am now studying to become Web Developer at "Visoka ICT Škola". In free time I program games and play them.
My Email<EMAIL_ADDRESS>My GitHub: GitHub
Or you can contact me here: Contact


WEEK 13 MONDAY
Year 1 (Year 2)
FIRST READING Genesis 18:16-33
A reading from the Book of Genesis
The men set out from the Oaks of Mamre, and they
looked toward
The word of the Lord
RESPONSORIAL PSALM Psalm 103:1-2.3-4.8-9.10-11 (R. 8a)
R. The Lord is compassionate and gracious.
Bless the LORD, O my soul, and all within me, his
holy name. Bless the LORD, O my soul, and never forget all his benefits.
R. The Lord is compassionate and gracious.
It is the LORD who forgives all your sins, who
heals every one of your ills, who redeems your life from the grave, who crowns
you with mercy and compassion.
R. The Lord is compassionate and gracious.
The LORD is compassionate and gracious,
slow to anger and rich in mercy. He will not always find fault; nor persist in
his anger for ever.
R. The Lord is compassionate and gracious.
He does not treat us according to our sins, nor
repay us according to our faults. For as the heavens are high
above the earth, so strong his mercy for those who fear him.
R. The Lord is compassionate and gracious.
FIRST READING Amos 2:6-10.13-16
A reading from the Book of the Prophet Amos
Thus says the LORD: "For three transgressions
of Israel, and for four, I will not revoke the punishment; because they sell
the righteous for silver, and the needy for a pair of shoes-- they that trample
the head of the poor into the dust of the earth, and turn aside the way of the
afflicted; a man and his father go in to the same maiden, so that my holy name
is profaned; they lay themselves down beside every altar upon garments taken in
pledge; and in the house of their God they drink the wine of those who have
been fined. "Yet I destroyed the Amorite before them, whose height was
like the height of the cedars, and who was as strong as the oaks; I destroyed
his fruit above, and his roots beneath. Also I brought you up out of the
The word of the Lord
RESPONSORIAL PSALM Psalm 16bc-17.18-20.21.22-23 (R. 22a)
R. Mark this, you who are forgetful of God.

R. Mark this, you who are forgetful of God.

R. Mark this, you who are forgetful of God.
'You do this, and should I keep silence? Do you
think I am like you? I accuse you, lay the charge before you.'
R. Mark this, you who are forgetful of God.
'Mark this, you who are forgetful of God, lest I
seize you and none can deliver you. A sacrifice of praise gives me honour, and
to one whose way is blameless, I will show the salvation of God.'
R. Mark this, you who are forgetful of God.
R. Alleluia. Today, harden not your hearts, but listen to the voice of the Lord. R. Alleluia.
GOSPEL Matthew 8:18-22
A reading from the holy Gospel according to Matthew
At that time: When Jesus saw great crowds around him,
he gave orders to go over to the other side. And a scribe came up and said to
him, "Teacher, I will follow you wherever you go." And Jesus said to
him, "Foxes have holes, and birds of the air have nests; but the Son of
man has nowhere to lay his head." Another of the disciples said to him,
"Lord, let me first go and bury my father." But Jesus said to him,
"Follow me, and leave the dead to bury their own dead."
The Gospel of the Lord


TensorBoard.dev enables you to easily host, track, and share your ML experiments with everyone. You can share a link to the uploaded TensorBoard in papers, blog posts, and social media. This can showcase the results more effectively and helps reproducibility.
To upload a logdir to TensorBoard.dev, run the command:
{{getCommandText()}}
Only certain plugins are currently supported. Uploaded TensorBoards are public and visible to everyone; do not upload sensitive data.


{% extends "base.html" %} {% block content %}
To get the most out of Tasking Manager, you need to have your profile as detailed as possible.
These 3 easy steps get you on your way to a great profile:
{{ loop.index }}
{% else %}
{% endif %} {{ step.title }}
{{ step.subtitle }}


There are several types of data used in JavaScript that serve as the basic building blocks of every program. These are called primitive data types and consist of the following types:
Any expression in JavaScript will return a value (e.g. 2 + 2 returns 4), and that value will have a type. For example, the result of 2 + 2 is 4 and 4's data type is a number. If you add 2 + "2", the result is "22", and "22" is a string.
A value's type, tells us what kind of "thing" it is.


{{define "index"}} {{template "header"}}
This is a template for a simple marketing or informational website. It includes a large callout called a jumbotron and three supporting pieces of content. Use it as a starting point to create something more unique.
Upload a file:


A peaceful peasant pasted a picture of a bowl of steaming pasta on the kitchen wall, to remind himself to always find inner calm and peace no matter how tumultuous the world around him became. [G|D]
The peaty soil of the forest floor was difficult to penetrate, but with great effort and precision, it finally yielded to the penetration of a spade. [G|D]
His biggest peeve was that the perceptual differences between himself and the other members of his family could never be reconciled, no matter how many pecans they ate together. [G|D]
The experienced pianist attempted to placate the picky audience with a skillful encore, but was unsuccessful in capturing their admiration with his impressive performance. [G|D]


| rand(min, max) |
Random number generator |
(rand(1, 10)) |
1 |
| stRand(min, max) |
Random number generator triggered every time the watch face goes between tappable active states |
(stRand(1, 10)) |
NaN |
| wakeRand(min, max) |
Random number generator that's updated every time the watch face goes into active mode |
(wakeRand(1, 10)) |
1 |
| abs(number) |
Absolute value function |
(abs(-10)) |
10 |
| sin(number) |
Sine function |
(sin(1)) |
0.8414709848078965 |
| cos(number) |
Cosine function |
(cos(1)) |
0.5403023058681398 |
| tan(number) |
Tangent function |
(tan(1)) |
1.5574077246549023 |
| round(number) |
Round function (get the closest integer) |
(round(1.6)) |
2 |
| ceil(number) |
Ceiling function (gets the next highest integer) |
(pi) |
3.141592653589793 |
| floor(number) |
Floor function - gets the next lowest integer) |
(pi) |
3.141592653589793 |
| log(number) |
Log function |
(log(2)) |
0.6931471805599453 |
| log2(number) |
Log base 2 function |
(log2(2)) |
1 |
| log10(number) |
Log base 10 function |
(log10(2)) |
0.3010299956639812 |
| sqrt(number) |
Square root function |
(sqrt(4)) |
2 |
| cbrt(number) |
Cube root function |
(cbrt(8)) |
2 |
| exp(number) |
Gets E to the x power |
(exp(2)) |
7.38905609893065 |
| expm1(number) |
Gets E to the x power minus 1 |
(expm1(2)) |
6.38905609893065 |
| deg(radians) |
Convert radians to degrees |
(deg(1)) |
57.29577951308232 |
| rad(degrees) |
Converts degrees to radians |
(rad(180)) |
3.141592653589793 |
| clamp(current, min, max) |
Restrict 'current' value to the 'min' & 'max' |
(clamp(#Ds#, 15, 45)) |
31 |
| squareWave(current, amplitude, period, xOffset) |
Creates a square wave pattern out of 'current' value |
(squareWave(#Ds#, 15, 10, 0)) |
15 |
| interpAccel(current, min, max, accelerationFactor) |
Creates a ease-in transition with 'current' value |
(interpAccel(#Ds#, 0, 60, 2)) |
0.2669444444444445 |
| interpDecel(current, min, max, accelerationFactor) |
Creates a ease-out transition with 'current' value |
(interpDecel(#Ds#, 0, 60, 2)) |
0.9454258487654321 |
| interpAccelDecel(current, min, max) |
Creates a ease-in-out transition with 'current' value |
(interpAccelDecel(#Ds#, 0, 60)) |
0.5261679781214715 |
| gyroX() |
Outputs the X axis of the gyro sensor, accumulated into positional coordinates |
3.9241372946780517 |
3.9241372946780517 |
| gyroY() |
Outputs the Y axis of the gyro sensor, accumulated into positional coordinates |
-1.0019503694835041 |
-1.0019503694835041 |
| accelerometerX() |
Outputs the X axis of the accelerometer sensor, accumulated into positional coordinates |
-5.273500685642811 |
-5.273500685642811 |
| accelerometerY() |
Outputs the Y axis of the accelerometer sensor, accumulated into positional coordinates |
7.629725700177308 |
7.629725700177308 |
| gyroRawX() |
Outputs the raw X axis of the gyro sensor, which detects rotational acceleration |
6.64500963775291 |
6.64500963775291 |
| gyroRawY() |
Outputs the raw Y axis of the gyro sensor, which detects rotational acceleration |
-3.9204606214134596 |
-3.9204606214134596 |
| accelerometerRawX() |
Outputs the raw X axis of the accelerometer sensor |
1.4595613230651239 |
1.4595613230651239 |
| accelerometerRawY() |
Outputs the raw Y axis of the accelerometer sensor |
9.87964297713896 |
9.87964297713896 |


Object pooling API.
The org.apache.commons.pool
package defines a simple
interface for a pool of object instances, and a handful of base
classes that may be useful when creating pool implementations.
The pool
package itself doesn't define a specific object
pooling implementation, but rather a contract that implementations may
support in order to be fully interchangeable.
The pool
package separates the way in which instances are
pooled from the way in which they are created, resulting in a pair of
interfaces:
{@link org.apache.commons.pool.ObjectPoolFactory ObjectPoolFactory}
defines a simple factory for ObjectPool
s, which may be
useful for some applications.
The pool
package also provides a keyed pool interface,
which pools instances of multiple types, accessed according to an
arbitrary key. See
{@link org.apache.commons.pool.KeyedObjectPool KeyedObjectPool},
{@link org.apache.commons.pool.KeyedPoolableObjectFactory KeyedPoolableObjectFactory},
and
{@link org.apache.commons.pool.KeyedObjectPoolFactory KeyedObjectPoolFactory}.


{{formObj.description}}
{{ el.version }}
Page with id "{{pageId}}" does not exist or could not be loaded.
Server not responding: {{serverError.name}}: {{serverError.message}}


import sys
import requests
from ..request import request
from ..request_class import Request
from ..habanero_utils import sub_str,check_kwargs
from .filters import filter_details
[docs]class Crossref(object):
'''
Crossref: Class for Crossref search API methods
|
|
**Includes methods matching Crossref API routes**
* /works - :func:`~habanero.Crossref.works`
* /members - :func:`~habanero.Crossref.members`
* /prefixes - :func:`~habanero.Crossref.prefixes`
* /funders - :func:`~habanero.Crossref.funders`
* /journals - :func:`~habanero.Crossref.journals`
* /types - :func:`~habanero.Crossref.types`
* /licenses - :func:`~habanero.Crossref.licenses`
Also:
* registration_agency - :func:`~habanero.Crossref.registration_agency`
* random_dois - :func:`~habanero.Crossref.random_dois`
**What am I actually searching when using the Crossref search API?**
You are using the Crossref search API described at
https://github.com/CrossRef/rest-api-doc/blob/master/rest_api.md.
When you search with query terms, on Crossref servers they are not
searching full text, or even abstracts of articles, but only what is
available in the data that is returned to you. That is, they search
article titles, authors, etc. For some discussion on this, see
https://github.com/CrossRef/rest-api-doc/issues/101
**The Polite Pool**
As of September 18th 2017 any API queries that use HTTPS and have
appropriate contact information will be directed to a special pool
of API machines that are reserved for polite users. If you connect
to the Crossreef API using HTTPS and provide contact
information, then they will send you to a separate pool of machines,
with better control the performance of these machines because they can
block abusive users.
We have been using `https` in `habanero` for a while now, so that's good
to go. To get into the Polite Pool, also set your mailto email address
when you instantiate the `Crossref` object. See examples below.
**Doing setup**::
from habanero import Crossref
cr = Crossref()
# set a different base url
Crossref(base_url = "http://some.other.url")
# set an api key
Crossref(api_key = "123456")
# set a mailto address
Crossref(mailto =<EMAIL_ADDRESS>.. _RateLimits:
**Rate limits**
See the headers `X-Rate-Limit-Limit` and `X-Rate-Limit-Interval` for current
rate limits. As of this writing the limit is 50 requests per second,
but that could change. In addiiton, it's not clear what the time is to reset.
See below for getting header info for your requests.
.. _CurlOpts:
**Verbose curl output**::
import requests
import logging
import httplib as http_client
http_client.HTTPConnection.debuglevel = 1
logging.basicConfig()
logging.getLogger().setLevel(logging.DEBUG)
requests_log = logging.getLogger("requests.packages.urllib3")
requests_log.setLevel(logging.DEBUG)
requests_log.propagate = True
import requests
import logging
logging.getLogger().setLevel(logging.DEBUG)
requests_log = logging.getLogger("requests.packages.urllib3")
requests_log.setLevel(logging.DEBUG)
requests_log.propagate = True
from habanero import Crossref
cr = Crossref()
cr.works(query = "ecology")
.. _FieldQueries:
**Field queries**
One or more field queries. Field queries are searches on specific fields.
For example, using `query_title` searches titles instead of full search
across all fields as would happen by default. Acceptable set of field
query parameters are:
* `query_title` - Query title and subtitle
* `query_container_title` - Query container-title aka. publication name
* `query_author` - Query author first and given names
* `query_editor` - Query editor first and given names
* `query_chair` - Query chair first and given names
* `query_translator` - Query translator first and given names
* `query_contributor` - Query author, editor, chair and translator first and given names
* `query_bibliographic` - Query bibliographic infomration, useful for citation look up. Includes titles, authors, ISSNs and publication years
* `query_affiliation` - Query contributor affiliations
.. _sorting:
**Sort options**
* `score` or `relevance` - Sort by relevance score
* `updated` - Sort by date of most recent change to metadata. Currently the same as deposited.
* `deposited` - Sort by time of most recent deposit
* `indexed` - Sort by time of most recent index
* `published` - Sort by publication date
* `published-print` - Sort by print publication date
* `published-online` - Sort by online publication date
* `issued` - Sort by issued date (earliest known publication date)
* `is-referenced-by-count` - Sort by number of references to documents
* `references-count` - Sort by number of references made by documents
.. _Facets:
**Facet count options**
* `affiliation` - Author affiliation. Allowed value: *
* `year` - Earliest year of publication, synonym for published. Allowed value: *
* `funder-name` - Funder literal name as deposited alongside DOIs. Allowed value: *
* `funder-doi` - Funder DOI. Allowed value: *
* `orcid` - Contributor ORCID. Max value: 100
* `container-title` - Work container title, such as journal title, or book title. Max value: 100
* `assertion` - Custom Crossmark assertion name. Allowed value: *
* `archive` - Archive location. Allowed value: *
* `update-type` - Significant update type. Allowed value: *
* `issn` - Journal ISSN (any - print, electronic, link). Max value: 100
* `published` - Earliest year of publication. Allowed value: *
* `type-name` - Work type name, such as journal-article or book-chapter. Allowed value: *
* `license` - License URI of work. Allowed value: *
* `category-name` - Category name of work. Allowed value: *
* `relation-type` - Relation type described by work or described by another work with work as object. Allowed value: *
* `assertion-group` - Custom Crossmark assertion group name. Allowed value: *
|
|
|
'''
def __init__(self, base_url = "https://api.crossref.org",
api_key = None, mailto = None):
self.base_url = base_url
self.api_key = api_key
self.mailto = mailto
def __repr__(self):
return """< %s \nURL: %s\nKEY: %s\nMAILTO: %s\n>""" % (type(self).__name__,
self.base_url, sub_str(self.api_key), self.mailto)
[docs] def works(self, ids = None, query = None, filter = None, offset = None,
limit = None, sample = None, sort = None,
order = None, facet = None, select = None, cursor = None,
cursor_max = 5000, **kwargs):
'''
Search Crossref works
:param ids: [Array] DOIs (digital object identifier) or other identifiers
:param query: [String] A query string
:param filter: [Hash] Filter options. See examples for usage.
Accepts a dict, with filter names and their values. For repeating filter names
pass in a list of the values to that filter name, e.g.,
`{'award_funder': ['10.13039/100004440', '10.13039/100000861']}`.
See https://github.com/CrossRef/rest-api-doc#filter-names
for filter names and their descriptions and :func:`~habanero.Crossref.filter_names`
and :func:`~habanero.Crossref.filter_details`
:param offset: [Fixnum] Number of record to start at, from 1 to 10000
:param limit: [Fixnum] Number of results to return. Not relavant when searching with specific dois.
Default: 20. Max: 1000
:param sample: [Fixnum] Number of random results to return. when you use the sample parameter,
the limit and offset parameters are ignored. Max: 100
:param sort: [String] Field to sort on. Note: If the API call includes a query, then the sort
order will be by the relevance score. If no query is included, then the sort order
will be by DOI update date. See sorting_ for possible values.
:param order: [String] Sort order, one of 'asc' or 'desc'
:param facet: [Boolean/String] Set to `true` to include facet results (default: false).
Optionally, pass a query string, e.g., `facet=type-name:*` or `facet=license=*`.
See Facets_ for options.
:param select: [String/list(Strings)] Crossref metadata records can be
quite large. Sometimes you just want a few elements from the schema. You can "select"
a subset of elements to return. This can make your API calls much more efficient. Not
clear yet which fields are allowed here.
:param cursor: [String] Cursor character string to do deep paging. Default is None.
Pass in '*' to start deep paging. Any combination of query, filters and facets may be
used with deep paging cursors. While rows may be specified along with cursor, offset
and sample cannot be used.
See https://github.com/CrossRef/rest-api-doc/blob/master/rest_api.md#deep-paging-with-cursors
:param cursor_max: [Fixnum] Max records to retrieve. Only used when cursor param used. Because
deep paging can result in continuous requests until all are retrieved, use this
parameter to set a maximum number of records. Of course, if there are less records
found than this value, you will get only those found.
:param kwargs: additional named arguments passed on to `requests.get`, e.g., field
queries (see examples and FieldQueries_)
:return: A dict
Usage::
from habanero import Crossref
cr = Crossref()
cr.works()
cr.works(ids = '10.1371/journal.pone.0033693')
dois = ['10.1371/journal.pone.0033693', ]
cr.works(ids = dois)
x = cr.works(query = "ecology")
x['status']
x['message-type']
x['message-version']
x['message']
x['message']['total-results']
x['message']['items-per-page']
x['message']['query']
x['message']['items']
# Get full text links
x = cr.works(filter = {'has_full_text': True})
x
# Parse output to various data pieces
x = cr.works(filter = {'has_full_text': True})
## get doi for each item
[ z['DOI'] for z in x['message']['items'] ]
## get doi and url for each item
[ {"doi": z['DOI'], "url": z['URL']} for z in x['message']['items'] ]
### print every doi
for i in x['message']['items']:
print i['DOI']
# filters - pass in as a dict
## see https://github.com/CrossRef/rest-api-doc#filter-names
cr.works(filter = {'has_full_text': True})
cr.works(filter = {'has_funder': True, 'has_full_text': True})
cr.works(filter = {'award_number': 'CBET-0756451', 'award_funder': '10.13039/100000001'})
## to repeat a filter name, pass in a list
x = cr.works(filter = {'award_funder': ['10.13039/100004440', '10.13039/100000861']}, limit = 100)
map(lambda z:z['funder'][0]['DOI'], x['message']['items'])
# Deep paging, using the cursor parameter
## this search should lead to only ~215 results
cr.works(query = "widget", cursor = "*", cursor_max = 100)
## this search should lead to only ~2500 results, in chunks of 500
res = cr.works(query = "octopus", cursor = "*", limit = 500)
sum([ len(z['message']['items']) for z in res ])
## about 167 results
res = cr.works(query = "extravagant", cursor = "*", limit = 50, cursor_max = 500)
sum([ len(z['message']['items']) for z in res ])
## cursor_max to get back only a maximum set of results
res = cr.works(query = "widget", cursor = "*", cursor_max = 100)
sum([ len(z['message']['items']) for z in res ])
## cursor_max - especially useful when a request could be very large
### e.g., "ecology" results in ~275K records, lets max at 10,000
### with 1000 at a time
res = cr.works(query = "ecology", cursor = "*", cursor_max = 10000, limit = 1000)
sum([ len(z['message']['items']) for z in res ])
items = [ z['message']['items'] for z in res ]
items = [ item for sublist in items for item in sublist ]
[ z['DOI'] for z in items ][0:50]
# field queries
res = cr.works(query = "ecology", query_author = 'carl boettiger')
[ x['author'][0]['family'] for x in res['message']['items'] ]
# select certain fields to return
## as a comma separated string
cr.works(query = "ecology", select = "DOI,title")
## or as a list
cr.works(query = "ecology", select = ["DOI","title"])
'''
if ids.__class__.__name__ != 'NoneType':
return request(self.mailto, self.base_url, "/works/", ids,
query, filter, offset, limit, sample, sort,
order, facet, select, None, None, None, None, **kwargs)
else:
return Request(self.mailto, self.base_url, "/works/",
query, filter, offset, limit, sample, sort,
order, facet, select, cursor, cursor_max, None, **kwargs).do_request()
[docs] def members(self, ids = None, query = None, filter = None, offset = None,
limit = None, sample = None, sort = None,
order = None, facet = None, works = False, select = None,
cursor = None, cursor_max = 5000, **kwargs):
'''
Search Crossref members
:param ids: [Array] DOIs (digital object identifier) or other identifiers
:param query: [String] A query string
:param filter: [Hash] Filter options. See examples for usage.
Accepts a dict, with filter names and their values. For repeating filter names
pass in a list of the values to that filter name, e.g.,
`{'award_funder': ['10.13039/100004440', '10.13039/100000861']}`.
See https://github.com/CrossRef/rest-api-doc#filter-names
for filter names and their descriptions and :func:`~habanero.Crossref.filter_names`
and :func:`~habanero.Crossref.filter_details`
:param offset: [Fixnum] Number of record to start at, from 1 to 10000
:param limit: [Fixnum] Number of results to return. Not relavant when searching with specific dois. Default: 20. Max: 1000
:param sample: [Fixnum] Number of random results to return. when you use the sample parameter,
the limit and offset parameters are ignored. This parameter only used when works requested. Max: 100
:param sort: [String] Field to sort on. Note: If the API call includes a query, then the sort
order will be by the relevance score. If no query is included, then the sort order
will be by DOI update date. See sorting_ for possible values.
:param order: [String] Sort order, one of 'asc' or 'desc'
:param facet: [Boolean/String] Set to `true` to include facet results (default: false).
Optionally, pass a query string, e.g., `facet=type-name:*` or `facet=license=*`
See Facets_ for options.
:param select: [String/list(Strings)] Crossref metadata records can be
quite large. Sometimes you just want a few elements from the schema. You can "select"
a subset of elements to return. This can make your API calls much more efficient. Not
clear yet which fields are allowed here.
:param works: [Boolean] If true, works returned as well. Default: false
:param kwargs: additional named arguments passed on to `requests.get`, e.g., field
queries (see examples and FieldQueries_)
:return: A dict
Usage::
from habanero import Crossref
cr = Crossref()
cr.members(ids = 98)
# get works
res = cr.members(ids = 98, works = True, limit = 3)
len(res['message']['items'])
[ z['DOI'] for z in res['message']['items'] ]
# cursor - deep paging
res = cr.members(ids = 98, works = True, cursor = "*")
sum([ len(z['message']['items']) for z in res ])
items = [ z['message']['items'] for z in res ]
items = [ item for sublist in items for item in sublist ]
[ z['DOI'] for z in items ][0:50]
# field queries
res = cr.members(ids = 98, works = True, query_author = 'carl boettiger', limit = 7)
[ x['author'][0]['family'] for x in res['message']['items'] ]
'''
return request(self.mailto, self.base_url, "/members/", ids,
query, filter, offset, limit, sample, sort,
order, facet, select, works, cursor, cursor_max, **kwargs)
[docs] def prefixes(self, ids = None, filter = None, offset = None,
limit = None, sample = None, sort = None,
order = None, facet = None, works = False, select = None,
cursor = None, cursor_max = 5000, **kwargs):
'''
Search Crossref prefixes
:param ids: [Array] DOIs (digital object identifier) or other identifiers
:param filter: [Hash] Filter options. See examples for usage.
Accepts a dict, with filter names and their values. For repeating filter names
pass in a list of the values to that filter name, e.g.,
`{'award_funder': ['10.13039/100004440', '10.13039/100000861']}`.
See https://github.com/CrossRef/rest-api-doc#filter-names
for filter names and their descriptions and :func:`~habanero.Crossref.filter_names`
and :func:`~habanero.Crossref.filter_details`
:param offset: [Fixnum] Number of record to start at, from 1 to 10000
:param limit: [Fixnum] Number of results to return. Not relavant when searching with specific dois. Default: 20. Max: 1000
:param sample: [Fixnum] Number of random results to return. when you use the sample parameter,
the limit and offset parameters are ignored. This parameter only used when works requested. Max: 100
:param sort: [String] Field to sort on. Note: If the API call includes a query, then the sort
order will be by the relevance score. If no query is included, then the sort order
will be by DOI update date. See sorting_ for possible values.
:param order: [String] Sort order, one of 'asc' or 'desc'
:param facet: [Boolean/String] Set to `true` to include facet results (default: false).
Optionally, pass a query string, e.g., `facet=type-name:*` or `facet=license=*`
See Facets_ for options.
:param select: [String/list(Strings)] Crossref metadata records can be
quite large. Sometimes you just want a few elements from the schema. You can "select"
a subset of elements to return. This can make your API calls much more efficient. Not
clear yet which fields are allowed here.
:param works: [Boolean] If true, works returned as well. Default: false
:param kwargs: additional named arguments passed on to `requests.get`, e.g., field
queries (see examples and FieldQueries_)
:return: A dict
Usage::
from habanero import Crossref
cr = Crossref()
cr.prefixes(ids = "10.1016")
cr.prefixes(ids = ['10.1016','10.1371','10.1023','10.4176','10.1093'])
# get works
cr.prefixes(ids = "10.1016", works = True)
# Limit number of results
cr.prefixes(ids = "10.1016", works = True, limit = 3)
# Sort and order
cr.prefixes(ids = "10.1016", works = True, sort = "relevance", order = "asc")
# cursor - deep paging
res = cr.prefixes(ids = "10.1016", works = True, cursor = "*", limit = 200)
sum([ len(z['message']['items']) for z in res ])
items = [ z['message']['items'] for z in res ]
items = [ item for sublist in items for item in sublist ]
[ z['DOI'] for z in items ][0:50]
# field queries
res = cr.prefixes(ids = "10.1371", works = True, query_editor = 'cooper', filter = {'type': 'journal-article'})
eds = [ x.get('editor') for x in res['message']['items'] ]
[ z for z in eds if z is not None ]
'''
check_kwargs(["query"], kwargs)
return request(self.mailto, self.base_url, "/prefixes/", ids,
query = None, filter = filter, offset = offset, limit = limit,
sample = sample, sort = sort, order = order, facet = facet,
select = select, works = works, cursor = cursor, cursor_max = cursor_max,
**kwargs)
[docs] def funders(self, ids = None, query = None, filter = None, offset = None,
limit = None, sample = None, sort = None,
order = None, facet = None, works = False, select = None,
cursor = None, cursor_max = 5000, **kwargs):
'''
Search Crossref funders
Note that funders without IDs don't show up on the `/funders` route,
that is, won't show up in searches via this method
:param ids: [Array] DOIs (digital object identifier) or other identifiers
:param query: [String] A query string
:param filter: [Hash] Filter options. See examples for usage.
Accepts a dict, with filter names and their values. For repeating filter names
pass in a list of the values to that filter name, e.g.,
`{'award_funder': ['10.13039/100004440', '10.13039/100000861']}`.
See https://github.com/CrossRef/rest-api-doc#filter-names
for filter names and their descriptions and :func:`~habanero.Crossref.filter_names`
and :func:`~habanero.Crossref.filter_details`
:param offset: [Fixnum] Number of record to start at, from 1 to 10000
:param limit: [Fixnum] Number of results to return. Not relavant when searching with specific dois. Default: 20. Max: 1000
:param sample: [Fixnum] Number of random results to return. when you use the sample parameter,
the limit and offset parameters are ignored. This parameter only used when works requested. Max: 100
:param sort: [String] Field to sort on. Note: If the API call includes a query, then the sort
order will be by the relevance score. If no query is included, then the sort order
will be by DOI update date. See sorting_ for possible values.
:param order: [String] Sort order, one of 'asc' or 'desc'
:param facet: [Boolean/String] Set to `true` to include facet results (default: false).
Optionally, pass a query string, e.g., `facet=type-name:*` or `facet=license=*`
See Facets_ for options.
:param select: [String/list(Strings)] Crossref metadata records can be
quite large. Sometimes you just want a few elements from the schema. You can "select"
a subset of elements to return. This can make your API calls much more efficient. Not
clear yet which fields are allowed here.
:param works: [Boolean] If true, works returned as well. Default: false
:param kwargs: additional named arguments passed on to `requests.get`, e.g., field
queries (see examples and FieldQueries_)
:return: A dict
Usage::
from habanero import Crossref
cr = Crossref()
cr.funders(ids = '10.13039/100000001')
cr.funders(query = "NSF")
# get works
cr.funders(ids = '10.13039/100000001', works = True)
# cursor - deep paging
res = cr.funders(ids = '10.13039/100000001', works = True, cursor = "*", limit = 200)
sum([ len(z['message']['items']) for z in res ])
items = [ z['message']['items'] for z in res ]
items = [ item for sublist in items for item in sublist ]
[ z['DOI'] for z in items ][0:50]
# field queries
res = cr.funders(ids = "10.13039/100000001", works = True, query_container_title = 'engineering', filter = {'type': 'journal-article'})
eds = [ x.get('editor') for x in res['message']['items'] ]
[ z for z in eds if z is not None ]
'''
return request(self.mailto, self.base_url, "/funders/", ids,
query, filter, offset, limit, sample, sort,
order, facet, select, works, cursor, cursor_max, **kwargs)
[docs] def journals(self, ids = None, query = None, filter = None, offset = None,
limit = None, sample = None, sort = None,
order = None, facet = None, works = False, select = None,
cursor = None, cursor_max = 5000, **kwargs):
'''
Search Crossref journals
:param ids: [Array] DOIs (digital object identifier) or other identifiers
:param query: [String] A query string
:param filter: [Hash] Filter options. See examples for usage.
Accepts a dict, with filter names and their values. For repeating filter names
pass in a list of the values to that filter name, e.g.,
`{'award_funder': ['10.13039/100004440', '10.13039/100000861']}`.
See https://github.com/CrossRef/rest-api-doc#filter-names
for filter names and their descriptions and :func:`~habanero.Crossref.filter_names`
and :func:`~habanero.Crossref.filter_details`
:param offset: [Fixnum] Number of record to start at, from 1 to 10000
:param limit: [Fixnum] Number of results to return. Not relavant when searching with specific dois. Default: 20. Max: 1000
:param sample: [Fixnum] Number of random results to return. when you use the sample parameter,
the limit and offset parameters are ignored. This parameter only used when works requested. Max: 100
:param sort: [String] Field to sort on. Note: If the API call includes a query, then the sort
order will be by the relevance score. If no query is included, then the sort order
will be by DOI update date. See sorting_ for possible values.
:param order: [String] Sort order, one of 'asc' or 'desc'
:param facet: [Boolean/String] Set to `true` to include facet results (default: false).
Optionally, pass a query string, e.g., `facet=type-name:*` or `facet=license=*`.
See Facets_ for options.
:param select: [String/list(Strings)] Crossref metadata records can be
quite large. Sometimes you just want a few elements from the schema. You can "select"
a subset of elements to return. This can make your API calls much more efficient. Not
clear yet which fields are allowed here.
:param works: [Boolean] If true, works returned as well. Default: false
:param kwargs: additional named arguments passed on to `requests.get`, e.g., field
queries (see examples and FieldQueries_)
:return: A dict
Usage::
from habanero import Crossref
cr = Crossref()
cr.journals(ids = "2167-8359")
cr.journals()
# pass many ids
cr.journals(ids = ['1803-2427', '2326-4225'])
# search
cr.journals(query = "ecology")
cr.journals(query = "peerj")
# get works
cr.journals(ids = "2167-8359", works = True)
cr.journals(ids = "2167-8359", query = 'ecology', works = True, sort = 'score', order = "asc")
cr.journals(ids = "2167-8359", query = 'ecology', works = True, sort = 'score', order = "desc")
cr.journals(ids = "2167-8359", works = True, filter = {'from_pub_date': '2014-03-03'})
cr.journals(ids = '1803-2427', works = True)
cr.journals(ids = '1803-2427', works = True, sample = 1)
cr.journals(limit: 2)
# cursor - deep paging
res = cr.funders(ids = '10.13039/100000001', works = True, cursor = "*", limit = 200)
sum([ len(z['message']['items']) for z in res ])
items = [ z['message']['items'] for z in res ]
items = [ item for sublist in items for item in sublist ]
[ z['DOI'] for z in items ][0:50]
# field queries
res = cr.journals(ids = "2167-8359", works = True, query_title = 'fish', filter = {'type': 'journal-article'})
[ x.get('title') for x in res['message']['items'] ]
'''
return request(self.mailto, self.base_url, "/journals/", ids,
query, filter, offset, limit, sample, sort,
order, facet, select, works, cursor, cursor_max, **kwargs)
[docs] def types(self, ids = None, query = None, filter = None, offset = None,
limit = None, sample = None, sort = None,
order = None, facet = None, works = False, select = None,
cursor = None, cursor_max = 5000, **kwargs):
'''
Search Crossref types
:param ids: [Array] Type identifier, e.g., journal
:param query: [String] A query string
:param filter: [Hash] Filter options. See examples for usage.
Accepts a dict, with filter names and their values. For repeating filter names
pass in a list of the values to that filter name, e.g.,
`{'award_funder': ['10.13039/100004440', '10.13039/100000861']}`.
See https://github.com/CrossRef/rest-api-doc#filter-names
for filter names and their descriptions and :func:`~habanero.Crossref.filter_names`
and :func:`~habanero.Crossref.filter_details`
:param offset: [Fixnum] Number of record to start at, from 1 to 10000
:param limit: [Fixnum] Number of results to return. Not relavant when searching with specific dois. Default: 20. Max: 1000
:param sample: [Fixnum] Number of random results to return. when you use the sample parameter,
the limit and offset parameters are ignored. This parameter only used when works requested. Max: 100
:param sort: [String] Field to sort on. Note: If the API call includes a query, then the sort
order will be by the relevance score. If no query is included, then the sort order
will be by DOI update date. See sorting_ for possible values.
:param order: [String] Sort order, one of 'asc' or 'desc'
:param facet: [Boolean/String] Set to `true` to include facet results (default: false).
Optionally, pass a query string, e.g., `facet=type-name:*` or `facet=license=*`
See Facets_ for options.
:param select: [String/list(Strings)] Crossref metadata records can be
quite large. Sometimes you just want a few elements from the schema. You can "select"
a subset of elements to return. This can make your API calls much more efficient. Not
clear yet which fields are allowed here.
:param works: [Boolean] If true, works returned as well. Default: false
:param kwargs: additional named arguments passed on to `requests.get`, e.g., field
queries (see examples and FieldQueries_)
:return: A dict
Usage::
from habanero import Crossref
cr = Crossref()
cr.types()
cr.types(ids = "journal")
cr.types(ids = "journal-article")
cr.types(ids = "journal", works = True)
# field queries
res = cr.types(ids = "journal-article", works = True, query_title = 'gender', rows = 100)
[ x.get('title') for x in res['message']['items'] ]
'''
return request(self.mailto, self.base_url, "/types/", ids,
query, filter, offset, limit, sample, sort,
order, facet, select, works, cursor, cursor_max, **kwargs)
[docs] def licenses(self, query = None, offset = None,
limit = None, sample = None, sort = None,
order = None, facet = None, **kwargs):
'''
Search Crossref licenses
:param query: [String] A query string
:param offset: [Fixnum] Number of record to start at, from 1 to 10000
:param limit: [Fixnum] Number of results to return. Not relavant when searching with specific dois. Default: 20. Max: 1000
:param sort: [String] Field to sort on. Note: If the API call includes a query, then the sort
order will be by the relevance score. If no query is included, then the sort order
will be by DOI update date. See sorting_ for possible values.
:param order: [String] Sort order, one of 'asc' or 'desc'
:param facet: [Boolean/String] Set to `true` to include facet results (default: false).
Optionally, pass a query string, e.g., `facet=type-name:*` or `facet=license=*`
See Facets_ for options.
:param kwargs: additional named arguments passed on to `requests.get`, e.g., field
queries (see examples and FieldQueries_)
:return: A dict
Usage::
from habanero import Crossref
cr = Crossref()
cr.licenses()
cr.licenses(query = "creative")
'''
check_kwargs(["ids", "filter", "works"], kwargs)
res = request(self.mailto, self.base_url, "/licenses/", None,
query, None, offset, limit, None, sort,
order, facet, None, None, None, None, **kwargs)
return res
[docs] def registration_agency(self, ids, **kwargs):
'''
Determine registration agency for DOIs
:param ids: [Array] DOIs (digital object identifier) or other identifiers
:param kwargs: additional named arguments passed on to `requests.get`, e.g., field
queries (see examples)
:return: list of DOI minting agencies
Usage::
from habanero import Crossref
cr = Crossref()
cr.registration_agency('10.1371/journal.pone.0033693')
cr.registration_agency(ids = ['10.1007/12080.1874-1746','10.1007/10452.1573-5125', '10.1111/(issn)1442-9993'])
'''
check_kwargs(["query", "filter", "offset", "limit", "sample", "sort",
"order", "facet", "works"], kwargs)
res = request(self.mailto, self.base_url, "/works/", ids,
None, None, None, None, None, None,
None, None, None, None, None, None, True, **kwargs)
if res.__class__ != list:
k = []
k.append(res)
else:
k = res
return [ z['message']['agency']['label'] for z in k ]
[docs] def random_dois(self, sample = 10, **kwargs):
'''
Get a random set of DOIs
:param sample: [Fixnum] Number of random DOIs to return. Default: 10. Max: 100
:param kwargs: additional named arguments passed on to `requests.get`, e.g., field
queries (see examples)
:return: [Array] of DOIs
Usage::
from habanero import Crossref
cr = Crossref()
cr.random_dois(1)
cr.random_dois(10)
cr.random_dois(50)
cr.random_dois(100)
'''
res = request(self.mailto, self.base_url, "/works/", None,
None, None, None, None, sample, None,
None, None, None, True, None, None, None, **kwargs)
return [ z['DOI'] for z in res['message']['items'] ]
[docs] @staticmethod
def filter_names():
'''
Filter names - just the names of each filter
Filters are used in the Crossref search API to modify searches
:return: dict
Usage::
from habanero import Crossref
cr = Crossref()
cr.filter_names()
'''
nms = list(filter_details.keys())
nms.sort()
return nms
[docs] @staticmethod
def filter_details():
'''
Filter details - filter names, possible values, and description
Filters are used in the Crossref search API to modify searches
:return: dict
Usage::
from habanero import Crossref
cr = Crossref()
cr.filter_details()
# Get descriptions for each filter
x = cr.filter_details()
[ z['description'] for z in x.values() ]
'''
return filter_details


{% load mfl_none_filter %}
Name: {{chu.name}}
Code: {{chu.code}}
Facility : {{chu.facility_name}}
County: {{chu.facility_county}}
Constituency: {{chu.facility_subcounty}}
Ward: {{chu.facility_ward}}
Location: {{chu.location | mfl_bool_none_date_filter}}
Date established: {{chu.date_established | mfl_bool_none_date_filter}}
Date operational: {{chu.date_operational | mfl_bool_none_date_filter}}
Households monitored: {{chu.households_monitored | mfl_bool_none_date_filter}}
Status: {{chu.status_name}}


--- layout: default footerlogos: yes title: "Speaker" lang: en ---
Maximilian created kleineAnfragen.de and sehrgutachten.de. For the Open Knowledge Foundation Germany he works on voluntary basis from Southern Germany, where he lives and works in his day-job at headissue.
Together with Arne Semsrott and Fiona Krakenbürger Maxi will give a lecture on »Civil society as an advocate of Open Data« on 28.04.2017.
Program for the first day


| 1 | package nl.tudelft.jpacman.npc.ghost; | |
| 2 | ||
| 3 | import java.util.EnumMap; | |
| 4 | import java.util.List; | |
| 5 | import java.util.Map; | |
| 6 | ||
| 7 | import nl.tudelft.jpacman.board.Direction; | |
| 8 | import nl.tudelft.jpacman.board.Square; | |
| 9 | import nl.tudelft.jpacman.level.Player; | |
| 10 | import nl.tudelft.jpacman.sprite.Sprite; | |
| 11 | ||
| 12 | /** | |
| 13 | *
 | |
| 14 | * An implementation of the classic Pac-Man ghost Pokey. | |
| 15 | *
 | |
| 16 | *
 | |
| 17 | * Nickname: Clyde. Pokey needs a new nickname because out of all the ghosts, | |
| 18 | * Pokey is the least likely to "C'lyde" with Pac-Man. Pokey is always the last | |
| 19 | * ghost out of the regenerator, and the loner of the gang, usually off doing | |
| 20 | * his own thing when not patrolling the bottom-left corner of the maze. His | |
| 21 | * behavior is very random, so while he's not likely to be following you in hot | |
| 22 | * pursuit with the other ghosts, he is a little less predictable, and still a | |
| 23 | * danger. In Japan, his name is Otoboke/Guzuta. | |
| 24 | *
 | |
| 25 | *
 | |
| 26 | * AI: Pokey has two basic AIs, one for when he's far from Pac-Man, and | |
| 27 | * one for when he is near to Pac-Man. When the ghosts are not patrolling their | |
| 28 | * home corners, and Pokey is far away from Pac-Man (beyond eight grid spaces), | |
| 29 | * Pokey behaves very much like Blinky, trying to move to Pac-Man's exact | |
| 30 | * location. However, when Pokey gets within eight grid spaces of Pac-Man, he | |
| 31 | * automatically changes his behavior and goes to patrol his home corner in the | |
| 32 | * bottom-left section of the maze. | |
| 33 | *
 | |
| 34 | *
 | |
| 35 | * Source: http://strategywiki.org/wiki/Pac-Man/Getting_Started | |
| 36 | *
 | |
| 37 | * | |
| 38 | * @author Jeroen Roosen | |
| 39 | * | |
| 40 | */ | |
| 41 | public class Clyde extends Ghost { | |
| 42 | ||
| 43 | /** | |
| 44 | * The amount of cells Clyde wants to stay away from Pac Man. | |
| 45 | */ | |
| 46 | private static final int SHYNESS = 8; | |
| 47 | ||
| 48 | /** | |
| 49 | * The variation in intervals, this makes the ghosts look more dynamic and | |
| 50 | * less predictable. | |
| 51 | */ | |
| 52 | private static final int INTERVAL_VARIATION = 50; | |
| 53 | ||
| 54 | /** | |
| 55 | * The base movement interval. | |
| 56 | */ | |
| 57 | private static final int MOVE_INTERVAL = 250; | |
| 58 | ||
| 59 | /** | |
| 60 | * A map of opposite directions. | |
| 61 | */ | |
| 62 | private static final Map<Direction, Direction> OPPOSITES = new EnumMap<>( | |
| 63 | Direction.class); | |
| 64 | static { | |
| 65 | OPPOSITES.put(Direction.NORTH, Direction.SOUTH); | |
| 66 | OPPOSITES.put(Direction.SOUTH, Direction.NORTH); | |
| 67 | OPPOSITES.put(Direction.WEST, Direction.EAST); | |
| 68 | OPPOSITES.put(Direction.EAST, Direction.WEST); | |
| 69 | } | |
| 70 | ||
| 71 | /** | |
| 72 | * Creates a new "Clyde", a.k.a. "Pokey". | |
| 73 | * | |
| 74 | * @param spriteMap | |
| 75 | * The sprites for this ghost. | |
| 76 | */ | |
| 77 | public Clyde(Map<Direction, Sprite> spriteMap) { | |
| 78 | super(spriteMap, MOVE_INTERVAL, INTERVAL_VARIATION); | |
| 79 | } | |
| 80 | ||
| 81 | /** | |
| 82 | * {@inheritDoc} | |
| 83 | * | |
| 84 | *
 | |
| 85 | * Pokey has two basic AIs, one for when he's far from Pac-Man, and one for | |
| 86 | * when he is near to Pac-Man. When the ghosts are not patrolling their home | |
| 87 | * corners, and Pokey is far away from Pac-Man (beyond eight grid spaces), | |
| 88 | * Pokey behaves very much like Blinky, trying to move to Pac-Man's exact | |
| 89 | * location. However, when Pokey gets within eight grid spaces of Pac-Man, | |
| 90 | * he automatically changes his behavior and goes to patrol his home corner | |
| 91 | * in the bottom-left section of the maze. | |
| 92 | *
 | |
| 93 | *
 | |
| 94 | * Implementation: Lacking a patrol function so far, Clyde will just | |
| 95 | * move in the opposite direction when he gets within 8 cells of Pac-Man. | |
| 96 | *
 | |
| 97 | */ | |
| 98 | @Override | |
| 99 | public Direction nextMove() { | |
| 100 | Square target = Navigation.findNearest(Player.class, getSquare()) | |
| 101 | .getSquare(); | |
| 102 | if (target == null) { | |
| 103 | return randomMove(); | |
| 104 | } | |
| 105 | ||
| 106 | List<Direction> path = Navigation.shortestPath(getSquare(), target, | |
| 107 | this); | |
| 108 | if (path != null && !path.isEmpty()) { | |
| 109 | Direction d = path.get(0); | |
| 110 |
1
1. nextMove : changed conditional boundary → SURVIVED |
if (path.size() <= SHYNESS) { |
| 111 | return OPPOSITES.get(d); | |
| 112 | } | |
| 113 | return d; | |
| 114 | } | |
| 115 | return randomMove(); | |
| 116 | } | |
| 117 | } | |
Mutations | ||
| 110 |
1.1 |


|
BL3 SDK
0.0.1
Borderlands 3 Class Documentation
|
#include <BL3_GbxWeapon_classes.hpp>
Public Member Functions | |
| void | ServerResetFireSequence () |
| void | OnStopFireRateDeceleration () |
| void | OnStopFireRateAcceleration () |
| void | OnStartFireRateDeceleration () |
| void | OnStartFireRateAcceleration () |
| void | OnRep_ImpactLocation () |
| void | OnRep_FlashCount () |
| void | OnRep_FireRateAccelChanged () |
| void | OnRep_ClientFireSequenceState () |
| void | OnReloadAmmoGiven () |
| void | OnLoopingFireActionEnd (EGbxActionEndState EndState) |
| void | OnGivenTo () |
| bool | IsFireRateAccelEnabled () |
| class AActor * | GetLockedTarget () |
| float | GetFireRatePercent () |
| void | ClientStopResetFireSequence () |
| Public Member Functions inherited from UWeaponUseComponent | |
| bool | ToggleMode () |
| void | SwitchToZoomedMode (unsigned char ZoomLevel) |
| void | SwitchFromZoomedMode (unsigned char ZoomLevel) |
| void | OnPreUseFinished (bool bInterrupted) |
| void | K2_OnDeactivated () |
| void | K2_OnActivated () |
| bool | CanActivateMode () |
| Public Member Functions inherited from UActorComponent | |
| void | ToggleActive () |
| void | SetTickGroup (TEnumAsByte< ETickingGroup > NewTickGroup) |
| void | SetTickableWhenPaused (bool bTickableWhenPaused) |
| void | SetOwningSceneCapture (class USceneCaptureComponent *InOwningSceneCapture) |
| void | SetIsReplicated (bool ShouldReplicate) |
| void | SetComponentTickInterval (float TickInterval) |
| void | SetComponentTickEnabled (bool bEnabled) |
| void | SetAutoActivate (bool bNewAutoActivate) |
| void | SetActive (bool bNewActive, bool bReset) |
| void | RemoveTickPrerequisiteComponent (class UActorComponent *PrerequisiteComponent) |
| void | RemoveTickPrerequisiteActor (class AActor *PrerequisiteActor) |
| void | ReceiveTick (float DeltaSeconds) |
| void | ReceiveEndPlay (TEnumAsByte< EEndPlayReason > EndPlayReason) |
| void | ReceiveBeginPlay () |
| void | OnRep_IsActive () |
| void | MarkNetDirty () |
| void | K2_DestroyComponent (class UObject *Object) |
| bool | IsComponentTickEnabled () |
| bool | IsBeingDestroyed () |
| bool | IsActive () |
| class USceneCaptureComponent * | GetOwningSceneCapture () |
| class AActor * | GetOwner () |
| float | GetComponentTickInterval () |
| void | Deactivate () |
| bool | ComponentHasTag (const struct FName &Tag) |
| void | AddTickPrerequisiteComponent (class UActorComponent *PrerequisiteComponent) |
| void | AddTickPrerequisiteActor (class AActor *PrerequisiteActor) |
| void | Activate (bool bReset) |
| Public Member Functions inherited from UObject | |
| std::string | GetName () const |
| std::string | GetFullName () const |
| bool | IsA (UClass *cmp) const |
| void | ProcessEvent (class UFunction *function, void *parms) |
| void | ExecuteUbergraph (int EntryPoint) |
Static Public Member Functions | |
| static UClass * | StaticClass () |
| Static Public Member Functions inherited from UWeaponUseComponent | |
| static UClass * | StaticClass () |
| Static Public Member Functions inherited from UActorComponent | |
| static UClass * | StaticClass () |
| Static Public Member Functions inherited from UObject | |
| static FChunkedFixedUObjectArray & | GetGlobalObjects () |
| template<typename T > | |
| static T * | FindObject (const std::string &name) |
| static UClass * | FindClass (const std::string &name) |
| template<typename T > | |
| static T * | GetObjectCasted (std::size_t index) |
| static UClass * | StaticClass () |
Additional Inherited Members | |
| Static Public Attributes inherited from UObject | |
| static FUObjectArray * | GObjects |
| void ClientStopResetFireSequence | ( | ) |
| float GetFireRatePercent | ( | ) |
| class AActor* GetLockedTarget | ( | ) |
| bool IsFireRateAccelEnabled | ( | ) |
| void OnGivenTo | ( | ) |
| void OnLoopingFireActionEnd | ( | EGbxActionEndState | EndState | ) |
| void OnReloadAmmoGiven | ( | ) |
| void OnRep_ClientFireSequenceState | ( | ) |
| void OnRep_FireRateAccelChanged | ( | ) |
| void OnRep_FlashCount | ( | ) |
| void OnRep_ImpactLocation | ( | ) |
| void OnStartFireRateAcceleration | ( | ) |
| void OnStartFireRateDeceleration | ( | ) |
| void OnStopFireRateAcceleration | ( | ) |
| void OnStopFireRateDeceleration | ( | ) |
| void ServerResetFireSequence | ( | ) |
|
inlinestatic |
| struct FGbxAttributeFloat AccuracyImpulse |
| struct FGbxParam AIAccuracy |
| struct FGbxParam AIBurstCount |
| struct FGbxParam AIBurstFireDelay |
| struct FNumericRange AIDesiredRange |
| struct FGbxParam AIFireInterval |
| struct FGbxParam AIMaxDesiredRange |
| struct FGbxParam AIMinDesiredRange |
| struct FGbxParam AIProjectileSpeedScale |
| struct FGbxAttributeInteger AutomaticBurstCount |
| bool bAdvanceFireSequenceAtEndOfBurst |
| bool bAutoBurst |
| unsigned char bFireRateAccelActive |
| bool bLockOntoBestTarget |
| unsigned char bPlayFeedbackAtLocation |
| unsigned char bScaleFeedbackWithFireRate |
| bool bSyncAnimationToFireRate |
| bool bTotalShotCostRequiredToFire |
| struct FGbxAttributeFloat BurstAccuracyImpulseScale |
| struct FGbxAttributeFloat BurstFireDelay |
| bool bUseShotStrengthFormula |
| unsigned char ClientFireSequenceState |
| int CurrentBurstShotCount |
| unsigned char CurrentFireSequenceIndex |
| struct FGbxAttributeFloat Damage |
| float DamageAmount |
| struct FAttributeInitializationData DamageFormula |
| struct FGbxAttributeFloat DamageRadius |
| struct FAttributeInitializationData DamageRadiusFormula |
| class UClass* DamageSource |
| class UClass* DamageType |
| float DelayInitializeAttribute |
| struct FRuntimeFloatCurve FeedbackFireRateScalar |
| struct FName FeedbackSocket |
| float FireAnimationBlendSpace |
| class UFeedbackData* FireFeedback |
| struct FGbxAttributeFloat FireRate |
| struct FGbxAttributeFloat FireRateAccelDuration |
| class UCurveFloat* FireRateCurve |
| struct FGbxAttributeFloat FireRateDecelDuration |
| float FireRatePercent |
| EWeaponFireRateState FireRateState |
| int FireSequenceLength |
| struct FName FireSocket |
| TArray<struct FName> FireSockets |
| struct FSoundPerceptionProperties FireSoundPerception |
| unsigned char FlashCount |
| unsigned char FlashSlot |
| bool FullFireSocketCycle |
| class UImpactData* ImpactData |
| struct FGbxAttributeFloat ImpactForce |
| struct FForceSelection ImpactForceSelection |
| struct FVector_NetQuantize ImpactLocation |
| float MinFireRatePercentToFire |
| float MinFireRateScale |
| int MinShotAmmoCost |
| int MuzzleFXSequenceLength |
| float ResetFireSequenceCompletePercent |
| struct FGbxAttributeFloat ResetFireSequenceTime |
| struct FGbxForceFeedbackEffect ScaledEffect |
| class UFeedbackData* ScaledFeedback |
| struct FGbxAttributeInteger ShotAmmoCost |
| class UCurveFloat* ShotStrengthDamageCurve |
| class UCurveFloat* ShotStrengthDamageRadiusCurve |
| struct FAttributeInitializationData ShotStrengthFormula |
| class UCurveFloat* ShotStrengthImpactForceCurve |
| float SkeletalControlFireInput |
| struct FName SkeletalControlName |
| TEnumAsByte<EWeaponEffectType> SkeletalControlType |
| struct FGbxAttributeFloat Spread |
| TEnumAsByte<ECollisionChannel> TraceChannel |
| unsigned char UnknownData00[0x3] |
| unsigned char UnknownData01[0x2] |
| unsigned char UnknownData02[0x4] |
| unsigned char UnknownData03[0x7] |
| unsigned char UnknownData04[0x2] |
| unsigned char UnknownData05[0x4] |
| unsigned char UnknownData06[0x4] |
| unsigned char UnknownData07[0x4] |
| unsigned char UnknownData08[0x7] |
| unsigned char UnknownData09[0x3] |
| unsigned char UnknownData10[0x7] |
| unsigned char UnknownData11[0x3] |
| unsigned char UnknownData12[0xD] |
| unsigned char UnknownData13 |
| unsigned char UnknownData14[0x2] |
| unsigned char UnknownData15[0x3] |
| unsigned char UnknownData16[0x10] |
| unsigned char UnknownData17[0x22] |
| unsigned char UnknownData18[0x14] |
| unsigned char UnknownData19[0x6] |
| unsigned char UnknownData20[0x10] |
| float ViewModelShotOffsetScale |


F
CS
cardSORTER
Toggle navigation
2 notifications
New charts available
View all
Guest
Moderator
Online Since 12:00
Followers
Remote Users
Devices
Profile
Sign out


Berlin FC defend Chapa Dimba N.Eastern title
by Capital SportGARISSA, Kenya, Nov 24 – Hosts Berlin FC reigned supreme as they saw off Al Ansar 2-0 to successfully defend the North Eastern Chapa Dimba Na Safaricom title in the first of the eight regions competition played on Sunday at the Technical Training College Grounds in Garissa.
Berlin FC, who pocketed Sh200,000 for lifting the title, will now once again for the second year running represent the North Eastern region in the National Finals set for June 2020 at the Bomu Stadium in Mombasa.
After a goalless first half, Berlin FC opened the scoring in the 67th minute through Noor Osman with Abdalla Marro adding a second in the 88th minute to retain the title for the Garissa–based team.
Last season, the two teams met in a tightly contested final where Berlin FC narrowly won via a penalty shootout.
“We have been training hard in preparation for this tournament, rectifying the past mistakes we made in the National Finals and this time we promise to put up a better performance to enable us come home with the main cup. I have also been crowned the most valuable player and I would like to thank my coach and my team as it was a collective effort that earned me this title,” Berlin FC striker Abdalla Marro, who was the Top Scorer with three goals said.
To reach the finals, Berlin FC beat Al Mumtaz from Modogashe 4-0 while Al Ansar from Wajir beat Admiral from Mandera 5-4 in post-match penalties.
The tournament now moves to Mombasa, where the Coast regional finals will be held on the weekend of December 7 at Bomu Stadium.
The Coast regional finals will also be accompanied by coaching clinics by La Liga coaches where they will be trained on how to build their skills to international standards.
Chapa Dimba Na Safaricom aims to develop grassroots football and providing a platform where gifted players will have an opportunity to be scouted and play for the National team as well as the top tier local and international teams.
Once all regional finals are played, an all-Star team comprising of 16 girls and 16 boys will be selected to attend a 10-day training camp in Spain.
The teams will play friendly matches against top Spanish La Liga Football Academies after which the players will rejoin their teams for the National finals where Sh1 million is at stake for the winner.
Awards
MVP –Noor Osman- (Berlin FC)
Golden Boot – Abdalla Marro- (Berlin FC)
Best Keeper/ Golden Glove Boys – Yahya Mohamed-1(Berlin)
Scouted for La Liga Training camp
First choice
- Noor Osman
- Abdalla Marro
Reserve list for La Liga training camp
- Ibrahim Billow Osman
- Khalid Yusuf
(Visited 16 times, 8 visits today)


Physical fitness is one of the most important prerequisites for joining the Air Force. Irrespective of the branch you are applying for, you must fulfil some basic physical standards. Listed below are some guidelines that identify the general physical requirements that are common for all candidates. . You must be in good physical and mental health and free from any disease/ disability, which is likely to interfere with efficient performance of duties. There should be no evidence of weak constitution or bodily defects.
(a) The duration of training will be 74 weeks for flying and technical branch and 52 weeks in case of Non-Tech branches. However, this period is subject to variations.
(b) The training at AFA demands a very high level of physical fitness. Outdoor activities are given equal importance as academics. Failure to achieve the desired standards in outdoor training and academics will result in termination of your training. Therefore, it is in your interest that you are physically and mentally prepared to undergo the rigours of training. You will be required to participate in athletics, cross country and games, so you should keep yourself fit to undertake physical exercise like sit ups, push-ups, short and long distance running etc. If you have any sportswear/ equipment like football boots, tennis racquet or golf sets, please bring them along with you. The minimum standards expected at AFA are given below:-
| Event Age | Bracket | Minimum Standard |
|---|---|---|
| 1.6 KM | Upto 25 years of age | 07.06-08.00 min |
| 1.6 KM | 26-30 years | 08.06-09.00 min |
| 100 mtr | Upto 35 years of age | 16 Sec |
| Push-Up & Sit-Up (in 01 min) | Upto 35 years of age | 20 |
| Chin-Up) | Upto 40 years of age | 03 |
| Swimming- 25 Mtr free style | ____ | Own time |
| Jump (swimming) | ____ | 7.5 Mtr |
| Event Age | Minimum Standard |
|---|---|
| 1.6 KM | 08.26-09.00 min |
| 100 mtr | 19 Sec |
| Push-Up Sit-Up (in 01 min) | 20 Sec |
| Sit-Up (in 01 min) | 15 |
| Chin-Up) | 02 |
| Swimming- 25 Mtr free style | Own time |
| Jump (swimming) | 5 Mtr |


You must enable JavaScript and provide an answer the following, simple challenge in order to complete the registration process.


interface BrowserInterface
Browser.
Methods
| BagInterface |
getCookies()
Return cookies. |
|
| BagInterface |
getSession()
Return session. |
|
| Response |
getLast()
Get last response. |
|
| Response |
get(string $url = '', string $body = '', array $headers = array())
Execute a GET request. |
|
| Response |
post(string $url = '', array $post = array(), array $files = array(), string $body = '', array $headers = array())
Execute a POST request. |
|
| Response |
put(string $url = '', array $post = array(), array $files = array(), string $body = '', array $headers = array())
Execute a PUT request. |
|
| Response |
delete(string $url = '', string $body = '', array $headers = array())
Execute a DELETE request. |
|
| Response |
req(string $url = '', string $method = 'GET', array $post = array(), array $file = array(), string $body = '', array $headers = array(), array $server = array())
Execute a request. |
|
|
catchException(boolean $catchException)
Set the catchException parameter. |
||
| Response |
submit(string $xpath = '//form', string $to = null, array $override = array())
Submit a form. |
Details
at line 13
public BagInterface
getCookies()
Return cookies.
at line 19
public BagInterface
getSession()
Return session.
at line 25
public Response
getLast()
Get last response.
at line 34
public Response
get(string $url = '', string $body = '', array $headers = array())
Execute a GET request.
at line 45
public Response
post(string $url = '', array $post = array(), array $files = array(), string $body = '', array $headers = array())
Execute a POST request.
at line 56
public Response
put(string $url = '', array $post = array(), array $files = array(), string $body = '', array $headers = array())
Execute a PUT request.
at line 65
public Response
delete(string $url = '', string $body = '', array $headers = array())
Execute a DELETE request.
at line 78
public Response
req(string $url = '', string $method = 'GET', array $post = array(), array $file = array(), string $body = '', array $headers = array(), array $server = array())
Execute a request.
at line 92
public
catchException(boolean $catchException)
Set the catchException parameter.
at line 101
public Response
submit(string $xpath = '//form', string $to = null, array $override = array())
Submit a form.


In this week, we did the Laser Cutting to make our own clock. Firstly, My design concept was Avengers. So I put Thor,Hawkeye and Iron Man on my design, change the picture to hairline, and put the file on usb. After that, I went to Laser printer to print my clock, and set up the printer with Mr.Gerber. Finally I waited infront of the laser printer untill the printing ended(to watch any fire), than I put the battery on my clock and finished. Secondly, I laser engraved a bookmark for the second project. My design concept was two big amusment park in Korea, Everland and Carribean bay. After the design I go through the similar process, put my file on USB, set up the printer, and waited for 15 minutes to finish my printing, Finally, I designed a Glass, using a new logo of Seoul.I go thorugh the similat process, put a picture in Coreldraw, and printed on the glass using a Laser cut printer.
The file and pictures that I made during this week


pepper.framework.sensor.asr module¶
-
class
pepper.framework.sensor.asr.
AbstractASR
(language='en-GB')[source]¶ Bases:
object
Abstract Automatic Speech Recognition (ASR)
Parameters: language (str) – Language Code <LC> & Region Code <RC> -> “LC-RC” -
MAX_ALTERNATIVES
= 10¶
-
language
¶ Automatic Speech Recognition Language
Returns: language – Language Code <LC> & Region Code <RC> -> “LC-RC” Return type: str
-
transcribe
(audio)[source]¶ Transcribe Speech in Audio
Parameters: audio (numpy.ndarray) – Audio Samples (Containing Speech) Returns: transcript Return type: List[UtteranceHypothesis]
-
-
class
pepper.framework.sensor.asr.
AbstractTranslator
(source, target)[source]¶ Bases:
object
Abstract Translator
Parameters: - source (str) – Two Character Source Language Code
- target (str) – Two Character Target Language Code
-
source
¶ Source Language
Returns: source – Two Character Source Language Code Return type: str
-
target
¶ Target Language
Returns: target – Two Character Target Language Code Return type: str
-
class
pepper.framework.sensor.asr.
BaseGoogleASR
(language='en-GB', sample_rate=16000, hints=())[source]¶ Bases:
pepper.framework.sensor.asr.AbstractASR
,pepper.framework.sensor.asr.GoogleTranslator
Abstract Base Google Automatic Speech Recognition (ASR)
Handles common parameters for SynchronousGoogleASR and StreamedGoogleASR
Parameters: - language (str) – Language Code <LC> & Region Code <RC> -> “LC-RC”
- sample_rate (int) – Number of Audio Samples per second that will be handled to ASR transcription (16k is nice!)
- hints (Tuple[str]) – Words or Phrases that ASR should be extra sensitive to
-
transcribe
(audio)[source]¶ Transcribe Speech in Audio
Parameters: audio (numpy.ndarray) – Audio Samples (Containing Speech) Returns: transcript Return type: List[UtteranceHypothesis]
-
class
pepper.framework.sensor.asr.
GoogleTranslator
(source, target)[source]¶ Bases:
pepper.framework.sensor.asr.AbstractTranslator
Google Translator
Parameters: - source (str) – Two Character Source Language Code
- target (str) – Two Character Target Language Code
-
class
pepper.framework.sensor.asr.
StreamedGoogleASR
(language='en-GB', sample_rate=16000, hints=())[source]¶ Bases:
pepper.framework.sensor.asr.BaseGoogleASR
Streamed Google Automatic Speech Recognition (ASR)
Recognises Speech ‘live’ as it is spoken. Should be faster than Synchronous ASR
Parameters: - language (str) – Language Code <LC> & Region Code <RC> -> “LC-RC”
- sample_rate (int) – Number of Audio Samples per second that will be handled to ASR transcription (16k is nice!)
- hints (Tuple[str]) – Words or Phrases that ASR should be extra sensitive to
-
live
¶ Live Speech Transcript String (Debug/Visual purposes only)
Returns: live – Live Speech Transcript String Return type: str
-
transcribe
(audio)[source]¶ Transcribe Speech in Audio (Streamed)
Instead of a single Block of Audio, this function takes an Iterable of Audio frames. One frame is processed at a time while the audio is being generated by the speaker. This provides a faster ASR than the synchronous version, and a live representation of the utterance. TODO: this breaks the abstract specification, is there a neater way to do this?
Parameters: audio (Iterable[numpy.ndarray]) – Iterable of Audio Samples (Containing Speech) Returns: transcript Return type: List[UtteranceHypothesis]
-
class
pepper.framework.sensor.asr.
SynchronousGoogleASR
(language='en-GB', sample_rate=16000, hints=())[source]¶ Bases:
pepper.framework.sensor.asr.BaseGoogleASR
Synchronous Google Automatic Speech Recognition (ASR)
Recognises Speech ‘live’ as it is spoken. Should be faster than Synchronous ASR
Parameters: - language (str) – Language Code <LC> & Region Code <RC> -> “LC-RC”
- sample_rate (int) – Number of Audio Samples per second that will be handled to ASR transcription (16k is nice!)
- hints (Tuple[str]) – Words or Phrases that ASR should be extra sensitive to
-
transcribe
(audio)[source]¶ Transcribe Speech in Audio
Parameters: audio (numpy.ndarray) – Returns: hypotheses Return type: List[UtteranceHypothesis]
-
class
pepper.framework.sensor.asr.
UtteranceHypothesis
(transcript, confidence)[source]¶ Bases:
object
Automatic Speech Recognition (ASR) Hypothesis
Parameters: - transcript (str) – Utterance Hypothesis Transcript
- confidence (float) – Utterance Hypothesis Confidence
-
confidence
¶ Automatic Speech Recognition Hypothesis Confidence
Returns: confidence Return type: float
-
transcript
¶ Automatic Speech Recognition Hypothesis Transcript
Returns: transcript Return type: str


|
GrimEngine
|
Base class for the game being developed. More...
#include <Engine.hpp>
Public Member Functions | |
| Engine (sf::Vector2i resolution=sf::Vector2i(800, 600), std::string windowName="GrimEngine") | |
| Creates the engine instance. More... | |
| virtual | ~Engine () |
| Virtual destructor. | |
| virtual void | init ()=0 |
| Used to load the initial state of the game. | |
| void | run (int minFPS) |
| Runs the game loop. More... | |
Protected Attributes | |
| sf::RenderWindow | _window |
| StateManager | _stateManager |
Base class for the game being developed.
The Game Class is used as a base class for any game that you want to make. It controls the state machine, window, window events, and updating the current state. When you inherit from this class to make your game you must define void init().
| Engine::Engine | ( | sf::Vector2i | resolution = sf::Vector2i(800, 600) , |
| std::string | windowName = "GrimEngine" |
||
| ) |
Creates the engine instance.
| resolution | Resolution of the game window |
| windowName | Name of the game window |
| void Engine::run | ( | int | minFPS | ) |
Runs the game loop.
| minFPS | Represents the minimum FPS the game should run at |


| TYPE | C*(*) | type of coordinates - `R', `H' or `A' (see below) |
|---|---|---|
| OB1 | D | observed Az, HA or RA (radians; Az is N=0, E=) |
| OB2 | D | observed zenith distance or (radians) |
| AOPRMS | D(14) | star-independent apparent-to-observed parameters: |
| (1) | geodetic latitude (radians) | |
| (2,3) | sine and cosine of geodetic latitude | |
| (4) | magnitude of diurnal aberration vector | |
| (5) | height (HM) | |
| (6) | ambient temperature (TDK) | |
| (7) | pressure (PMB) | |
| (8) | relative humidity (RH) | |
| (9) | wavelength (WL) | |
| (10) | lapse rate (TLR) | |
| (11,12) | refraction constants A and B (radians) | |
| (13) | longitude + eqn of equinoxes + ``sidereal UT'' (radians) | |
| (14) | local apparent sidereal time (radians) |
| RAP,DAP | D | geocentric apparent |
|---|
for . Even at a topocentric zenith distance of , the accuracy in elevation should be better than 1 arcminute; useful results are available for a further , beyond which the sla_REFRO routine returns a fixed value of the refraction. The complementary routines sla_AOP (or sla_AOPQK) and sla_OAP (or sla_OAPQK) are self-consistent to better than 1 microarcsecond all over the celestial sphere.
SLALIB --- Positional Astronomy Library


Big O notation is the language we use for talking about how long an algorithm takes to run. It’s how we compare the efficiency of different approaches to a problem.
With big O notation we express the runtime in terms of
So instead of talking about the runtime directly, we use big O notation to talk about how quickly the runtime grows.
we could express our speed in seconds. Since we’re measuring how quickly our runtime grows, we need to express our speed in terms of…something else. With Big O notation, we use the size of the input, which we call “n.” So we can say things like the runtime grows “on the order of the size of the input” () or “on the order of the square of the size of the input” (). 3. as the input gets arbitrarily large—
Our algorithm may have steps that seem expensive when n is small but are eclipsed eventually by other steps as n gets huge. For big O analysis, we care most about the stuff that grows fastest as the input grows, because everything else is quickly eclipsed as n gets very large. (If you know what an asymptote is, you might see why “big O analysis” is sometimes called “asymptotic analysis.”)hy “big O analysis” is sometimes called “asymptotic analysis.”)
| # Data Structures Reference |
Stores things in order. Has quick lookups by index.
Also stores things in order. Faster insertions and deletions than arrays, but slower lookups (you have to “walk down” the whole list).
!
Like the line outside a busy restaurant. “First come, first served.”
Like a stack of dirty plates in the sink. The first one you take off the top is the last one you put down.
Good for storing hierarchies. Each node can have “child” nodes.
Everything in the left subtree is smaller than the current node, everything in the right subtree is larger. lookups, but only if the tree is balanced!
Good for storing networks, geography, social relationships, etc.
A binary tree where the smallest value is always at the top. Use it to implement a priority queue.
[A binary heap is a binary tree where the nodes are organized to so that the smallest value is always at the top.]
A list where the index represents the node and the value at that index is a list of the node’s neighbors:
graph = [ [1], [0, 2, 3], [1, 3], [1, 2], ]
Since node 3 has edges to nodes 1 and 2, graph[3] has the adjacency list [1, 2].
We could also use a dictionary where the keys represent the node and the values are the lists of neighbors.
graph = { 0: [1], 1: [0, 2, 3], 2: [1, 3], 3: [1, 2], }
This would be useful if the nodes were represented by strings, objects, or otherwise didn’t map cleanly to list indices.
A matrix of 0s and 1s indicating whether node x connects to node y (0 means no, 1 means yes).
graph = [ [0, 1, 0, 0], [1, 0, 1, 1], [0, 1, 0, 1], [0, 1, 1, 0], ]
Since node 3 has edges to nodes 1 and 2, graph[3][1] and graph[3][2] have value 1.
a = LinkedListNode(5) b = LinkedListNode(1) c = LinkedListNode(9) a.next = b b.next = c
Ok, so we know how to store individual numbers. Let’s talk about storing several numbers.
That’s right, things are starting to heat up.
Suppose we wanted to keep a count of how many bottles of kombucha we drink every day.
Let’s store each day’s kombucha count in an 8-bit, fixed-width, unsigned integer. That should be plenty—we’re not likely to get through more than 256 (2^8) bottles in a single day, right?
And let’s store the kombucha counts right next to each other in RAM, starting at memory address 0:
Bam. That’s an array. RAM is basically an array already.
Just like with RAM, the elements of an array are numbered. We call that number the index of the array element (plural: indices). In this example, each array element’s index is the same as its address in RAM.
But that’s not usually true. Suppose another program like Spotify had already stored some information at memory address 2:
We’d have to start our array below it, for example at memory address 3. So index 0 in our array would be at memory address 3, and index 1 would be at memory address 4, etc.:
Suppose we wanted to get the kombucha count at index 4 in our array. How do we figure out what address in memory to go to? Simple math:
Take the array’s starting address (3), add the index we’re looking for (4), and that’s the address of the item we’re looking for. 3 + 4 = 7. In general, for getting the nth item in our array:
\text{address of nth item in array} = \text{address of array start} + n
This works out nicely because the size of the addressed memory slots and the size of each kombucha count are both 1 byte. So a slot in our array corresponds to a slot in RAM.
But that’s not always the case. In fact, it’s usually not the case. We usually use 64-bit integers.
So how do we build an array of 64-bit (8 byte) integers on top of our 8-bit (1 byte) memory slots?
We simply give each array index 8 address slots instead of 1:
So we can still use simple math to grab the start of the nth item in our array—just gotta throw in some multiplication:
\text{address of nth item in array} = \text{address of array start} + (n * \text{size of each item in bytes})
Don’t worry—adding this multiplication doesn’t really slow us down. Remember: addition, subtraction, multiplication, and division of fixed-width integers takes time. So all the math we’re using here to get the address of the nth item in the array takes time.
And remember how we said the memory controller has a direct connection to each slot in RAM? That means we can read the stuff at any given memory address in time.
Together, this means looking up the contents of a given array index is time. This fast lookup capability is the most important property of arrays.
But the formula we used to get the address of the nth item in our array only works if:
number of bytes).
be any gaps in the array…like to “skip over” a memory slot Spotify was already using.
These things make our formula for finding the nth item work because they make our array predictable. We can predict exactly where in memory the nth element of our array will be.
But they also constrain what kinds of things we can put in an array. Every item has to be the same size. And if our array is going to store a lot of stuff, we’ll need a bunch of uninterrupted free space in RAM. Which gets hard when most of our RAM is already occupied by other programs (like Spotify).
That’s the tradeoff. Arrays have fast lookups ( time), but each item in the array needs to be the same size, and you need a big block of uninterrupted free memory to store the array.
## Pointers
Remember how we said every item in an array had to be the same size? Let’s dig into that a little more.
Suppose we wanted to store a bunch of ideas for baby names. Because we’ve got some really cute ones.
Each name is a string. Which is really an array. And now we want to store those arrays in an array. Whoa.
Now, what if our baby names have different lengths? That’d violate our rule that all the items in an array need to be the same size!
We could put our baby names in arbitrarily large arrays (say, 13 characters each), and just use a special character to mark the end of the string within each array…
“Wigglesworth” is a cute baby name, right?
But look at all that wasted space after “Bill”. And what if we wanted to store a string that was more than 13 characters? We’d be out of luck.
There’s a better way. Instead of storing the strings right inside our array, let’s just put the strings wherever we can fit them in memory. Then we’ll have each element in our array hold the address in memory of its corresponding string. Each address is an integer, so really our outer array is just an array of integers. We can call each of these integers a pointer, since it points to another spot in memory.
The pointers are marked with a * at the beginning.
Pretty clever, right? This fixes both the disadvantages of arrays:
long or as short as we want.
strings next to each other—we can place each of them separately, wherever there’s space in RAM.
We fixed it! No more tradeoffs. Right?
Nope. Now we have a new tradeoff:
Remember how the memory controller sends the contents of nearby memory addresses to the processor with each read? And the processor caches them? So reading sequential addresses in RAM is faster because we can get most of those reads right from the cache?
Our original array was very cache-friendly, because everything was sequential. So reading from the 0th index, then the 1st index, then the 2nd, etc. got an extra speedup from the processor cache.
But the pointers in this array make it not cache-friendly, because the baby names are scattered randomly around RAM. So reading from the 0th index, then the 1st index, etc. doesn’t get that extra speedup from the cache.
That’s the tradeoff. This pointer-based array requires less uninterrupted memory and can accommodate elements that aren’t all the same size, but it’s slower because it’s not cache-friendly.
This slowdown isn’t reflected in the big O time cost. Lookups in this pointer-based array are still time.
Our word processor is definitely going to need fast appends—appending to the document is like the main thing you do with a word processor.
Can we build a data structure that can store a string, has fast appends, and doesn’t require you to say how long the string will be ahead of time?
Let’s focus first on not having to know the length of our string ahead of time. Remember how we used pointers to get around length issues with our array of baby names?
What if we pushed that idea even further?
What if each character in our string were a two-index array with:
We would call each of these two-item arrays a node and we’d call this series of nodes a linked list.
Here’s how we’d actually implement it in memory:
Notice how we’re free to store our nodes wherever we can find two open slots in memory. They don’t have to be next to each other. They don’t even have to be in order:
“But that’s not cache-friendly,” you may be thinking. Good point! We’ll get to that.
The first node of a linked list is called the head, and the last node is usually called the tail.
Confusingly, some people prefer to use “tail” to refer to everything after the head of a linked list. In an interview it’s fine to use either definition. Briefly say which definition you’re using, just to be clear.
It’s important to have a pointer variable referencing the head of the list—otherwise we’d be unable to find our way back to the start of the list!
We’ll also sometimes keep a pointer to the tail. That comes in handy when we want to add something new to the end of the linked list. In fact, let’s try that out:
Suppose we had the string “LOG” stored in a linked list:
Suppose we wanted to add an “S” to the end, to make it “LOGS”. How would we do that?
Easy. We just put it in a new node:
And tweak some pointers:
1. Grab the last letter, which is “G”. Our tail pointer lets us do this in time.
2. Point the last letter’s next to the letter we’re appending (“S”).
3. Update the tail pointer to point to our new last letter, “S”.
That’s time.
Why is it time? Because the runtime doesn’t get bigger if the string gets bigger. No matter how many characters are in our string, we still just have to tweak a couple pointers for any append.
Now, what if instead of a linked list, our string had been a dynamic array? We might not have any room at the end, forcing us to do one of those doubling operations to make space:
So with a dynamic array, our append would have a worst-case time cost of .
Linked lists have worst-case -time appends, which is better than the worst-case time of dynamic arrays.
That worst-case part is important. The average case runtime for appends to linked lists and dynamic arrays is the same: .
Now, what if we wanted to prepend something to our string? Let’s say we wanted to put a “B” at the beginning.
For our linked list, it’s just as easy as appending. Create the node:
And tweak some pointers:
Bam. time again.
But if our string were a dynamic array…
And we wanted to add in that “B”:
Eep. We have to make room for the “B”!
We have to move each character one space down:
Now we can drop the “B” in there:
What’s our time cost here?
It’s all in the step where we made room for the first letter. We had to move all n characters in our string. One at a time. That’s time.
So linked lists have faster prepends ( time) than dynamic arrays ( time).
No “worst case” caveat this time—prepends for dynamic arrays are always time. And prepends for linked lists are always time.
These quick appends and prepends for linked lists come from the fact that linked list nodes can go anywhere in memory. They don’t have to sit right next to each other the way items in an array do.
So if linked lists are so great, why do we usually store strings in an array? Because arrays have -time lookups. And those constant-time lookups come from the fact that all the array elements are lined up next to each other in memory.
Lookups with a linked list are more of a process, because we have no way of knowing where the ith node is in memory. So we have to walk through the linked list node by node, counting as we go, until we hit the ith item.
def get_ith_item_in_linked_list(head, i): if i < 0: raise ValueError(“i can’t be negative: %d” % i) current_node = head current_position = 0 while current_node: if current_position == i: # Found it! return current_node # Move on to the next node current_node = current_node.next current_position += 1 raise ValueError(‘List has fewer than i + 1 (%d) nodes’ % (i + 1))
That’s i + 1 steps down our linked list to get to the ith node (we made our function zero-based to match indices in arrays). So linked lists have -time lookups. Much slower than the -time lookups for arrays and dynamic arrays.
Not only that—walking down a linked list is not cache-friendly. Because the next node could be anywhere in memory, we don’t get any benefit from the processor cache. This means lookups in a linked list are even slower.
So the tradeoff with linked lists is they have faster prepends and faster appends than dynamic arrays, but they have slower lookups.
## Doubly Linked Lists
In a basic linked list, each item stores a single pointer to the next element.
In a doubly linked list, items have pointers to the next and the previous nodes.
Doubly linked lists allow us to traverse our list backwards. In a singly linked list, if you just had a pointer to a node in the middle of a list, there would be no way to know what nodes came before it. Not a problem in a doubly linked list.
Most computers have caching systems that make reading from sequential addresses in memory faster than reading from scattered addresses.
Array items are always located right next to each other in computer memory, but linked list nodes can be scattered all over.
So iterating through a linked list is usually quite a bit slower than iterating through the items in an array, even though they’re both theoretically time.
## Hash tables
Quick lookups are often really important. For that reason, we tend to use arrays (-time lookups) much more often than linked lists (-time lookups).
For example, suppose we wanted to count how many times each ASCII character appears in Romeo and Juliet. How would we store those counts?
We can use arrays in a clever way here. Remember—characters are just numbers. In ASCII (a common character encoding) ‘A’ is 65, ‘B’ is 66, etc.
So we can use the character(’s number value) as the index in our array, and store the count for that character at that index in the array:
With this array, we can look up (and edit) the count for any character in constant time. Because we can access any index in our array in constant time.
Something interesting is happening here—this array isn’t just a list of values. This array is storing two things: characters and counts. The characters are implied by the indices.
So we can think of an array as a table with two columns…except you don’t really get to pick the values in one column (the indices)—they’re always 0, 1, 2, 3, etc.
But what if we wanted to put any value in that column and still get quick lookups?
Suppose we wanted to count the number of times each word appears in Romeo and Juliet. Can we adapt our array?
Translating a character into an array index was easy. But we’ll have to do something more clever to translate a word (a string) into an array index…
Here’s one way we could do it:
Grab the number value for each character and add those up.
The result is 429. But what if we only have 30 slots in our array? We’ll use a common trick for forcing a number into a specific range: the modulus operator (%). Modding our sum by 30 ensures we get a whole number that’s less than 30 (and at least 0):
429 \: \% \: 30 = 9
Bam. That’ll get us from a word (or any string) to an array index.
This data structure is called a hash table or hash map. In our hash table, the counts are the values and the words (“lies,” etc.) are the keys (analogous to the indices in an array). The process we used to translate a key into an array index is called a hashing function.
![A blank array except for a 20, labeled as the value, stored at index
arrow pointing to the right at diamond with a question mark in the middle, labeled as the hashing function. The diamond points to the 9th index of the array.](https://www.interviewcake.com/images/svgs/cs_for_hackers__hash_tables_lies_key_labeled.svg?bust=209)
The hashing functions used in modern systems get pretty complicated—the one we used here is a simplified example.
Note that our quick lookups are only in one direction—we can quickly get the value for a given key, but the only way to get the key for a given value is to walk through all the values and keys.
Same thing with arrays—we can quickly look up the value at a given index, but the only way to figure out the index for a given value is to walk through the whole array.
One problem—what if two keys hash to the same index in our array? Look at “lies” and “foes”:
They both sum up to 429! So of course they’ll have the same answer when we mod by 30:
429 \: \% \: 30 = 9
So our hashing function gives us the same answer for “lies” and “foes.” This is called a hash collision. There are a few different strategies for dealing with them.
Here’s a common one: instead of storing the actual values in our array, let’s have each array slot hold a pointer to a linked list holding the counts for all the words that hash to that index:
One problem—how do we know which count is for “lies” and which is for “foes”? To fix this, we’ll store the word as well as the count in each linked list node:
“But wait!” you may be thinking, “Now lookups in our hash table take time in the worst case, since we have to walk down a linked list.” That’s true! You could even say that in the worst case every key creates a hash collision, so our whole hash table degrades to a linked list.
In industry though, we usually wave our hands and say collisions are rare enough that on average lookups in a hash table are time. And there are fancy algorithms that keep the number of collisions low and keep the lengths of our linked lists nice and short.
But that’s sort of the tradeoff with hash tables. You get fast lookups by key…except some lookups could be slow. And of course, you only get those fast lookups in one direction—looking up the key for a given value still takes time. —— — <==(——————————————————————————————————)==> — ——
Breadth-first search (BFS) is a method for exploring a tree or graph. In a BFS, you first explore all the nodes one step away, then all the nodes two steps away, etc.
Breadth-first search is like throwing a stone in the center of a pond. The nodes you explore “ripple out” from the starting point.
Here’s a how a BFS would traverse this tree, starting with the root:
We’d visit all the immediate children (all the nodes that’re one step away from our starting node):
Then we’d move on to all those nodes’ children (all the nodes that’re two steps away from our starting node):
And so on:
Until we reach the end.
Breadth-first search is often compared with depth-first search.
Advantages:
any other reachable node. A depth-first search will not necessarily find the shortest path.
Disadvantages
A binary tree is a tree where <==(every node has two or fewer children)==>. The children are usually called left and right.
class BinaryTreeNode(object):
This lets us build a structure like this:
That particular example is special because every level of the tree is completely full. There are no “gaps.” We call this kind of tree “perfect.”
Binary trees have a few interesting properties when they’re perfect:
Property 1: the number of total nodes on each “level” doubles as we move down the tree.
Property 2: the number of nodes on the last level is equal to the sum of the number of nodes on all other levels (plus 1). In other words, about half of our nodes are on the last level.
<==(Let’s call the number of nodes n,)==>
<==(and the height of the tree h. )==>
h can also be thought of as the “number of levels.”
If we had h, how could we calculate n?
Let’s just add up the number of nodes on each level!
If we zero-index the levels, the number of nodes on the xth level is exactly 2^x.
So our total number of nodes is:
n = 2^0 + 2^1 + 2^2 + 2^3 + … + 2^{h-1}
Why only up to 2^{h-1}?
Notice that we started counting our levels at 0.
But we can simplify.
Property 2 tells us that the number of nodes on the last level is (1 more than) half of the total number of nodes,
so we can just take the number of nodes on the last level, multiply it by 2, and subtract 1 to get the number of nodes overall.
We know the number of nodes on the last level is 2^{h-1},
So:
n = 2^{h-1} * 2 - 1 n = 2^{h-1} * 2^1 - 1 n = 2^{h-1+1}- 1 n = 2^{h} - 1
So that’s how we can go from h to n. What about the other direction?
We need to bring the h down from the exponent.
That’s what logs are for!
First, some quick review.
<==(log_{10} (100) )==>
simply means,
“What power must you raise 10 to in order to get 100?”.
Which is 2,
because .
<==(10^2 = 100 )==>
Graph =====
Let’s put those bits to use. Let’s store some stuff. Starting with numbers.
The number system we usually use (the one you probably learned in elementary school) is called base 10, because each digit has ten possible values (1, 2, 3, 4, 5, 6, 7, 8, 9, and 0).
But computers don’t have digits with ten possible values. They have bits with two possible values. So they use base 2 numbers.
Base 10 is also called decimal. Base 2 is also called binary.
To understand binary, let’s take a closer look at how decimal numbers work. Take the number “101” in decimal:
Notice we have two “1”s here, but they don’t mean the same thing. The leftmost “1” means 100, and the rightmost “1” means 1. That’s because the leftmost “1” is in the hundreds place, while the rightmost “1” is in the ones place. And the “0” between them is in the tens place.
So this “101” in base 10 is telling us we have “1 hundred, 0 tens, and 1 one.”
Notice how the places in base 10 (ones place, tens place, hundreds place, etc.) are sequential powers of 10:
The places in binary (base 2) are sequential powers of 2:
So let’s take that same “101” but this time let’s read it as a binary number:
Reading this from right to left: we have a 1 in the ones place, a 0 in the twos place, and a 1 in the fours place. So our total is 4 + 0 + 1 which is 5.
Here’s how we’d count up to 12 in binary:


Datasets
A number of different datasets are available for download at: https://demuc.de/colmap/datasets/
Gerrard Hall: 100 high-resolution images of the “Gerrard” hall at UNC Chapel Hill, which is the building right next to the “South” building. The images are taken with the same camera but different focus using a wide-angle lens.
Graham Hall: 1273 high-resolution images of the interior and exterior of “Graham” memorial hall at UNC Chapel Hill. The images are taken with the same camera but different focus using a wide-angle lens.
Person Hall: 330 high-resolution images of the “Person” hall at UNC Chapel Hill. The images are taken with the same camera using a wide-angle lens.
South Building: 128 images of the “South” building at UNC Chapel Hill. The images are taken with the same camera, kindly provided by Christopher Zach.
A number of sample reconstructions produced by COLMAP can be viewed here:
Sparse reconstructions:
Dense reconstructions:


--- layout: page title: About header-img: "img/about-bg.png" ---
Leah is a member of the Ember.js Core Team and an organizer of numerous annual tech events, like RustConf, EmberConf and RailsConf. She's worked with open source projects (like jQuery, Bundler and Merb) to help build communities and events. She has a background in startup marketing in community-oriented engineering environments, and is CEO at Tilde Inc. She is the author of Event Driven, the guide to running successful tech events.