- Breaking change: Scripts and plugins must be placed inside subfolders
- New: Avarage update size reduced from 60MB to 2MB
- New: Updates are not downloaded in background anymore, only after user confirms installation
- New: VC++ Redistributable is installed during update only if needed
- New: Added button to check for new updates
- New: Playnite will close gracefully when Windows is shutting down
- New: Added GameStarting event to extension API
- New: "Modern" color profile for "Classic" theme
- Fix: UI polish by spektor56
- Fix: Team Fortress 2 not showing on Playnite
- Fix: Some Steam games not tracking time/detecting game closure
- Fix: Retroarch not getting focus properly when launched
- Fix: Newly installed games not launching
- Fix: Missing localizable strings
- Fix: Install watcher not working properly for Origin games
- Fix: Game scan failing on folders with ".exe" in their name
- Fix: Game list not aligned properly in fullscreen mode
- Fix: FullScreen user interface only responds to player 1 controller
- Fix: Crash on Inaccessible Database


What we do
We provide a unique proof of any electronic document and we record this information (notarise it). The result is a mathematical proof of your original document. Stored forever on the Blockchain.
read moreHow it works
Using our service, you will get the ultimate proof of your digital document yet it's secure and nobody but you gets to access the content whilst everybody has an ability to verify it's authenticity.
read moreHow much does it cost?
The total cost for this service is 1.00 ETH for all of your documents and we give you the lifetime warranty for your document proof guaranteed by the Ethereum Blockchain network. read more
Notarise Your Document
Waiting for confirmation of transaction…
If it has been certified already, you will be redirected to the original record.
You can also input a hash to find previous records.
Add your document for digital verification
Simply drag and drop documents that you want to digitally verify and we will compute the cryptographic hash and record these hashes on the Blockchain. This is done in your browser so the contents of your files remain confidential.
Record the document proof on the Blockchain
We store the SHA-2 hash of your file, the SHA-2 hash of your email and the timestamp on the Blockchain. The timestamp is generated by the Blockchain, so there is no chance of tampering.
You get an email containing Blockchain referal link
Once your document hash has been written on the Blockchain and we will send you a referal link to your own unique cryptographic proof of the document.
Documents of proven existence (notarised) and on the blockchain.
| Document Digest | Timestamp |
|---|---|
| Loading history… |
Documents already registered for certification, waiting for payments.
| Document Digest | Timestamp |
|---|---|
| Loading history… |


| Home | Trees | Indices | Help |
|
|---|
|
|
wx.App --+ | PlotApp
A wxApp that provides a matplotlib canvas embedded in a wxPython top-level window, encapsulating wxPython's nuts and bolts.
| Instance Methods | |||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
|||
|
| Class Variables | |
ABOUT_TITLE = None Title of the "About" dialog. |
|
ABOUT_MESSAGE = None Contents of the "About" dialog. |
| Method Details |
Creates a new PlotApp, which creates a PlotFrame top-level window. The keyword argument All of other the named keyword arguments to this constructor have the
same meaning as those arguments to the constructor of
Any additional keyword arguments are passed to the constructor of
|
Enable or disable the changing mouse cursor. When enabled, the cursor changes from the normal arrow to a square cross when the mouse enters a matplotlib axes on this canvas. |
| Home | Trees | Indices | Help |
|
|---|
| Generated by Epydoc 3.0.1 on Mon Oct 17 15:08:20 2011 | http://epydoc.sourceforge.net |


async-each 1.0.0 (26 November 2015)
- Bumped version to 1.0.0 (no functional changes)
async-each 0.1.6 (5 November 2014)
- Add license to package.json
async-each 0.1.5 (22 October 2014)
- Clean up package.json to fix npm warning about
repo
async-each 0.1.4 (12 November 2013)
async-each 0.1.3 (25 July 2013)
- Fixed double wrapping of errors.
async-each 0.1.2 (7 July 2013)
- Fixed behaviour on empty arrays.
async-each 0.1.1 (14 June 2013)
- Wrapped function in closure, enabled strict mode.
async-each 0.1.0 (14 June 2013)


Select a country
Algeria
Antarctica
Argentina
Armenia
Australia
Austria
Azerbaijan
Bangladesh
Belarus
Belgium
Bolivia
Bosnia and Herzegovina
Brazil
Bulgaria
Canada
Chile
China
Colombia
Croatia
Cuba
Cyprus
Czechia
Denmark
Dominican Republic
Egypt
El Salvador
Estonia
Finland
France
Georgia
Germany
Greece
Hong Kong
Hungary
India
Indonesia
Iran
Israel
Italy
Japan
Jordan
Kazakhstan
Kuwait
Kyrgyzstan
Latvia
Lebanon
Lithuania
Macedonia
Malaysia
Mexico
Moldova
Mongolia
Morocco
Nepal
Netherlands
Nigeria
North Korea
Pakistan
Palestinian Territory
Peru
Philippines
Poland
Portugal
Romania
Russia
Saudi Arabia
Serbia
Singapore
Slovakia
Slovenia
South Korea
Spain
Sri Lanka
Sweden
Switzerland
Syria
Taiwan
Tajikistan
Thailand
Tunisia
Turkey
Turkmenistan
Ukraine
United Kingdom
United States
Unknown
Uzbekistan
Venezuela
Vietnam
Zimbabwe
Go to standings
Please enter a gym or a contest in Codeforces.


Search Navigation
{{pdf.data.date | date: 'fullDate'}} by {{pdf.data.author}}
{{pdf.data.error}} Take me somewhere safe!


Hello and welcome!!
The premis is simple, use your mouse to collect as many green blocks as you can
The Rules:
1. Collect the green dots
2. Avoid the red dots
3. Green dots make your collector bigger
4. Red dots make your collector smaller
5.  After you collect 30 blocks you advance to the next level (speeds up and more dots)
7. After each level you gain a new life
8. Collect blue dots to gain an extra life
9. Lose all your lives and GAME OVER.....
Start


You are not an Administrator! You do not have access to this route.
Edit Review Visibility
If a review is selected to be hidden or infringing, it will be hidden from the public. Only courses where both the "hidden" property and "infringing" property is set to false will be visible for the public to view.


|
Kabbalahaka Qabala, Cabala, Kabala, Qabballa, etc.Imagine you're Madonna. You're too smart for Scientology, but not calm enough for Taoism. You've pretty much burned your bridges with Catholicism. And Methodism was never really an option. So where do you go for your religious fulfillment?If you're thinking Hinduism, well, actually she was over that back in the '90s after it failed to catch on as the Next Big Thing. Her current fixation, kabbalah, might have more potential. Technically, kabbalah is not a religion, and it never was. It originated around the 11th century as an outgrowth of earlier Jewish esoteric-occult traditions. Kabbalah is mainly based on two texts, the Sepher Yetzirah ("the book of creation") and the Zohar ("the book of enlightenment"). Sepher Yetzirah is a collection of secret traditions supposedly passed down from Abraham. It describes the structure of the universe and the method of its creation, including an extremely convoluted series of planes of existence, based on geometry and key numerical sequences derived from the Hebrew alphabet. While probably not dating back to the time of Abraham, whenever that actually was, it is the older of the two texts and probably runs at least as far back as the second century B.C. The Zohar was first seen in public during the 13th century, offered up by Moses de Leon, a Spanish Jew who claimed it was the work of a second-century miracle-working rabbi. After de Leon's death, there were numerous charges that the work was a forgery. There is quite a bit of legitimate controversy around the book, but the scholarly consensus is that the Zohar legitimately conveys a tradition that predates the 13th century, including several elements found in Jewish and Christian Gnosticism. The Zohar is a commentary on the Pentateuch, the first five books of both the Jewish and Christian bibles. OK, maybe "commentary" isn't the right word. The Zohar claims that the words of the Torah are simply a smokescreen behind which the real meaning of the Jewish scriptures lurks, like an ancient stereogram: you can't see it unless you're looking past it. Together, the books outline a sweeping vision of the structure of reality, including guidelines on how to alter it in nontraditional ways, which more or less amount to magic. Based on the two key texts, medieval occultists and Jewish mystics created a massive body of writings about metaphysics, alchemy and magic. Because it covers material related to the Old Testament, kabbalah was adopted by both Jews and Christians. Kabbalism also led to the development of Hasidism among Eastern European Jews. The most readily identifiable concept in kabbalism is the Tree of Life, a diagram that is essentially a map of reality. The Tree of Life consists of three columns known as "pillars", and 10 sephiroth, or spheres, each of which represents an aspect of the process God used to create the world. At the top of the diagram is Kether, "The Crown", which represents the divine intelligence of God, from which all of creation emanates. The three pillars emanate down from Kether all the way down to Malkuth at the bottom. (The word means "Kingdom"; the bottom sephira is also sometimes called Shekhinah.) Kether is the angle at which reality points toward the creator; Malkuth is the angle at which is points toward His creation -- the earthly world. In traditional kabbalism, there are 10 sephiroth, although some schools teach of a "hidden" 11th in the middle of the diagram. Each sephira has different characteristics and is represented by a different Hebrew letter, which also corresponds to a number. The 10 sephiroth are connected by 22 lines, known as "paths," each of which carries a specific meaning. Some occult traditions teach that the paths correspond to the major arcana in the Tarot. The chart comes to life as a result of emanations, a concept which covers the movement of will, force, divine spark, light, energy and reality from God to creation. Emanations are the manifestation of divine intelligence as a material or metaphysical thing, such as an angel or a soul. Because the shape of emanations is outlined by the Tree of Life (supplemented by information contained in numerous other kabbalistic writings), the Tree and the Hebrew alphabet can be used to calculate the "true names" of things. If you know the true name of something, you can control it, which quickly led medieval kabbalists to become ritual magicians (as well as inspiring medieval ritual magicians to become kabbalists). With kabbalistic secrets firmly in hand, the well-informed can construct magic words that presumably empower users to command the very forces of the universe. Angels and demons, in particular, are susceptible to this sort of control. Truly ambitious sorcerers also sought the true name of God, the most powerful magic word imaginable. The search for God's true name took on epic proportions during the middle ages. The name was referred to as the Tetragrammaton, because it was believed to have four letters. The Torah provides one version of this name, of course, which practicing Jews are forbidden to speak -- YHWH, pronounced as Yahweh (or JHVH, Jehovah) by those who are not especially worried about eternal damnation and a divine curse. YHWH is derived from the first letter of each Hebrew word God spoke to Moses from the burning bush story found in Exodus. The rough English translation of the statement is "I am who am", "I am who I am", or "I am that I am." Finding the name in the Bible, of course, was far too easy. Obviously, recipients of secret knowledge would have a better name, a more powerful name. Unfortunately, no one could quite agree on what that name was, although a number of alternatives were proposed, such as AGLA or ADNI. None of these names hold up to the obvious test: After pronouncing them, neither divine wrath nor infinite power arrives within any reasonable time frame. Other esoteric concepts were covered in some depth by the kabbalists. Many kabbalists were also alchemists and scientists. As a result, some kabbalistic texts about the nature of emanations and the behavior of light (as a divine power) have a remarkable power even to this day. For instance, one Latin kabbalistic text from the Middle Ages discusses the properties of spirit and body in some detail. If you substitute "spirit" for "energy" and "matter" for "body", the text looks suspiciously like a sneak preview of Einstein's theory of relativity. To a greater or lesser extent, kabbalism is the basis of nearly every tradition covered under the general heading of "occultism". Kabbalah is the basis for the rumored occult practices of the Freemasons, the Illuminati and the Knights Templar, the stylings of the O.T.O., the antichrist rituals of Jack Parsons, and the creation of mystical beings such as the Golem. Scientology is also roughly modeled on the kabbalah, albeit filtered through a Battlestar Galactica sensibility. When it started, the study of kabbalah was secretive, especially among medieval Christians who feared the wrath of the Inquisition. After Aleister Crowley exposed the secrets of the Golden Dawn in the early 20th century, the cat was out of the bag, and kabbalah began to be talked about among the religious intellectuals of the day. Crowley himself wrote extensively about the kabbalah for the general public, as well as for his fellow students of esoterica. The movie Pi (1998) was a cult hit featuring a gang of malevolent Hasidic Jews who are searching for a way to decipher the true name of God from the number codes in the Torah. The movie coincided with a revival of mainstream interest in kabbalah. The latest iteration of kabbalism has more in common with the New Age than with traditional occultism. Kabbalah centers (both Jewish and non-Jewish versions) have popped up around the United States. Perhaps partly as a result of widespread coverage of Scientology's quirks, a fair number of celebrities have embraced kabbalism as the spiritual flavor of the month. In addition to Madonna, celebrity kabbalists include Elizabeth Taylor, Demi Moore, Mick Jagger, Jeff Goldblum, Ivana Trump, and Roseanne Barr. Although the new kabbalism downplays claims of exotic superpowers, the magical aspect of kabbalism is still an important part of the modern movement. While the conceptual underpinnings of kabbalah are pretty sophisticated, you can still shout "Yahweh sucks" at the top of your lungs for hours on end without producing the slightest whiff of brimstone. You might get hoarse, but that's not exactly an impressive display of God's wrath. On the other hand, you can do the same thing using "Allah," "Vishnu" or "Jesus" in the place of Yahweh. Kabbalism isn't any more disreputable than any other spiritual path, it's just more explicit in telling you how to get what you want. You could do worse.
|


L
O
A
D
I
N
G
Logged Users:
#000
#250
User
#000
00:00:00
If you see this message it means something is not functioning properly.
You are logged in as:
#000
Your IP is: <IP_ADDRESS>


This city is best known in Europe as the hub of the European Union as many of its institutions are located here.
Position 50° 53'05"N, 004° 22'55"E (marina)
It is possible for yachts to reach Brussels via the canal network from Amsterdam without having to lower the mast.
Last updated March 2016.


Hello! I'm Alic Szecsei. I am currently a Master's student in Computer Science at the University of Iowa, where I received my bachelor's degree in 2014. Computer science and interactive storytelling have long been my driving passions.
I joined EPX Studio at the University of Iowa in 2016, and became Scheduling Director in 2017. I have taken part in multiple game jams, including Train Jam, Ludum Dare, the 7-Day Roguelike, and more.


You will find some cool patterns here.
daf efss rgdfg dfbsfmn umuj bdb dfew erger grd sffef fr efrere ge gee ger erre


Both arguments (lines 3 and 4) represent the two types of floating point literals
that are available in Java; float (32 bit) and
double (64 bit), respectively. In either case, including the
whole number part, 0, is optional. However, a float must
always be succeeded by the letter F (upper or, lower case) – while following
a double value with the letter d (upper or, lower case) is optional.
Lines 5 and 6 illustrate a float and double that include an exponent. When the
exponent portion includes a signed integer (as these do), if that integer is positive, including
the + sign is optional (e.g. line 5). However, if the signed integer is negative, a negative sign
preceding it must be included (e.g. line 6).
The result of running this code is:
0.8
0.8
20.0
9.0E-9


Add information about your business below. Your business page will not appear in search results until
this information has been verified and approved by our moderators.
Once it is approved, you'll receive an email with instructions on how to claim your business page.


Welcome to Sample University.
Event & Planning
Bio-chemistry
Meeting
Studing
Team Work
IT Coures
In Campus


|
.NET Framework | |||||||||
| PREV TYPE NEXT TYPE | FRAMES NO FRAMES | |||||||||
| SUMMARY: INNER | FIELD | CONST | PROP | METHOD | OP | EVENT | DETAIL: FIELD | CONST | PROP | METHOD | OP | EVENT |
| Field Summary | |
|---|---|
| string | INFILENAME |
| string | OUTFILENAME |
| Fields inherited from class SourceForge.NAnt.Element |
|---|
| _location, _parent, _project, _xmlNode |
| Constructor Summary | |
|---|---|
|
DvslTask() Initializes a new instance of the DvslTask class. |
| Property Summary | |
|---|---|
| string |
Destdir
Set the destination directory where the generated files should be directed. |
| string |
Extension
Set the desired file extension to be used for the target files. If not specified, " .html" is used. |
| SourceForge.NAnt.FileSet |
FileSet
The set of files to be included in the archive. |
| bool |
Force
Set whether to check dependencies, or always generate. |
| string |
In
Sets an input xml file to be styled |
| string |
LogFile
Sets the file to use for logging. If not specified, all logging is directed through NAnt's logging system. |
| string |
Out
Sets an output file |
| string |
OutputEncoding
Sets the character encoding for output files. If not specified, output is written with UTF-8 encodin6g. |
| string |
Style
Sets the file to use for stylesheet. |
| string |
ToolboxFile
Sets the Toolbox properties file to use. |
| bool |
ValidatingParser
Sets the flag to have DVSL use a validating parser for the input documents |
| Properties inherited from class SourceForge.NAnt.Task |
|---|
| FailOnError, IfDefined, LogPrefix, Name, UnlessDefined, Verbose |
| Properties inherited from class SourceForge.NAnt.Element |
|---|
| Location, Parent, Project, Properties |
| Method Summary | |
|---|---|
| void | ExecuteTask() |
| void |
PutAppValue(string name, object o) Sets an application value from outside of the DVSL task |
| void | xExecuteTask() |
| Methods inherited from class SourceForge.NAnt.Task |
|---|
| Execute, InitializeElement, InitializeTask |
| Methods inherited from class SourceForge.NAnt.Element |
|---|
| Initialize |
| Methods inherited from class System.Object |
|---|
| Equals, Finalize, GetHashCode, GetType, MemberwiseClone, ToString |
| Field Detail |
|---|
public string INFILENAME
public string OUTFILENAME
| Constructor Detail |
|---|
public DvslTask()
Initializes a new instance of the DvslTask class.
| Property Detail |
|---|
public string Destdir
Set the destination directory where the generated files should be directed.
public string Extension
Set the desired file extension to be used for the target files. If not specified, "
.html" is used.
public SourceForge.NAnt.FileSet FileSet
The set of files to be included in the archive.
public bool Force
Set whether to check dependencies, or always generate.
public string In
Sets an input xml file to be styled
public string LogFile
Sets the file to use for logging. If not specified, all logging is directed through NAnt's logging system.
public string Out
Sets an output file
public string OutputEncoding
Sets the character encoding for output files. If not specified, output is written with UTF-8 encodin6g.
public string Style
Sets the file to use for stylesheet.
public string ToolboxFile
Sets the Toolbox properties file to use.
public bool ValidatingParser
Sets the flag to have DVSL use a validating parser for the input documents
| Method Detail |
|---|
protected void ExecuteTask()
public void PutAppValue(string name, object o)
Sets an application value from outside of the DVSL task
Parameters:
name
- o
- protected void xExecuteTask()
|
.NET Framework | |||||||||
| PREV TYPE NEXT TYPE | FRAMES NO FRAMES | |||||||||
| SUMMARY: INNER | FIELD | CONST | PROP | METHOD | OP | EVENT | DETAIL: FIELD | CONST | PROP | METHOD | OP | EVENT |


|
Computes of an approximate reciprocal of the low single-precision floating-point value in the source operand (second operand) and stores the single-precision floating-point result in the destination operand. The source operand can be an XMM register or a 32-bit memory location.
The destination operand is an XMM register. The three high-order doublewords of the destination operand remain unchanged. See Figure 10-6 in the IA-32 Intel Architecture Software Developer's Manual, Volume 1 for an illustration of a scalar single-precision floating-point operation.
The relative error for this approximation is:
|Relative Error| <= 1.5 * 2-12 The RCPSS instruction is not affected by the rounding control bits in the MXCSR register.
When a source value is a 0.0, an infinite of the sign of the source value is returned. A denormal source value is treated as a 0.0 (of the same sign). Tiny results are always flushed to 0.0, with the sign of the operand. (Input values greater than or equal to |1.11111111110100000000000B*2125| are guaranteed to not produce tiny results; input values less than or equal to |1.00000000000110000000001B*2126| are guaranteed to produce tiny results, which are in turn flushed to 0.0; and input values in between this range may or may not produce tiny results, depending on the implementation.) When a source value is an SNaN or QNaN, the SNaN is converted to a QNaN or the source QNaN is returned.
|


From:Neiman Marcus To:Tracy Geaccone Sent:2017-01-11T04:37:09.0000000Z Subject:The Best Accessories for Fall
SWEET TREATS
Our fresh, feel-good accessories are an instant boost for your wardrobe.
Some of our favorites:
A poncho in Burberry's classic novacheck.
http://neimanmarcus.chtah.com/a/tA7xcslAB8$L1AHaLXyADpOJ-.AB$a5d6Q/nm1
kate spade's fun red tweed handbag.
http://neimanmarcus.chtah.com/a/tA7xcslAB8$L1AHaLXyADpOJ-.AB$a5d6Q/nm2
Cole Haan's comfy leather loafers with pebbled soles.
http://neimanmarcus.chtah.com/a/tA7xcslAB8$L1AHaLXyADpOJ-.AB$a5d6Q/nm3
Funky fabulous fur in blue, from Trilogy.
http://neimanmarcus.chtah.com/a/tA7xcslAB8$L1AHaLXyADpOJ-.AB$a5d6Q/nm4
A bright yellow watch on a patent strap, from Michele Watches.
http://neimanmarcus.chtah.com/a/tA7xcslAB8$L1AHaLXyADpOJ-.AB$a5d6Q/nm5
A trendy belt, from Streets Ahead.
http://neimanmarcus.chtah.com/a/tA7xcslAB8$L1AHaLXyADpOJ-.AB$a5d6Q/nm6
Click to shop these and more.
http://neimanmarcus.chtah.com/a/tA7xcslAB8$L1AHaLXyADpOJ-.AB$a5d6Q/nm7
Click to shop our 2001 Christmas Book Online, one-of-a-kind gifts for everyone on your list.
http://neimanmarcus.chtah.com/a/tA7xcslAB8$L1AHaLXyADpOJ-.AB$a5d6Q/nm8
Our legendary one-on-one service is just a click away: Contact a
Neiman Marcus personal shopper.
http://neimanmarcus.chtah.com/a/tA7xcslAB8$L1AHaLXyADpOJ-.AB$a5d6Q/nm9
Click To E-mail A Friend
http://neimanmarcus.chtah.com/a/tA7xcslAB8$L1AHaLXyADpOJ-.AB$a5d6Q/nm10?userid=61137535&password=aehirybfv.ipe&pid=124302834
Friends can subscribe to NeimanMarcus.com e-mail by sending
an e-mail to the following address and typing SUBSCRIBE
in the subject line:
<EMAIL_ADDRESS>P.S. If you would prefer not to receive future e-mails from
Neiman Marcus, simply reply to:
<EMAIL_ADDRESS>***********
EDRM Enron Email Data Set has been produced in EML, PST and NSF format by ZL Technologies, Inc. This Data Set is licensed under a Creative Commons Attribution 3.0 United States License <http://creativecommons.org/licenses/by/3.0/us/> . To provide attribution, please cite to "ZL Technologies, Inc. (http://www.zlti.com)."
***********
California


About
My name is Tarun Sachdeva. I'm the GM of Tap by Wattpad, a platform for enjoying interactive stories.
I use this space to write everyday - to clarify my thoughts, learn through writing, and sometimes just journal and post things I find interesting.
Subscribe
RSS
Contact
Twitter
Instagram
Email
Github


Tracking:
Target page:
Count:
Total execution time (ms):
Average execution time (ms):
Standard deviation (ms):
Load Testing


Alaska Airlines, Surfline offer special deal on flights to Hawaii, prices depend on waves
by KGOSAN FRANCISCO -- If you have the sudden itch to take a trip to Hawaii, Alaska Airlines is helping you out. It's teaming up with Surfline to slash ticket prices this week depending on how high the waves are around the islands.
There's a pun for the promotion name, "Swell Deals".
Any waves higher than 21 feet get you 30% off, ranging down to 10% off for any waves less than 10 feet. The discount applies for flights booked until Friday November 8, 2019. You must travel by November 20, 2019.
To take advantage of the of the deal you have to enter the code "SURFLINE15" in all caps at checkout.


Rules
Controls
Other
The object of Star Jumper is (to be determined)...


Application Form
Application Category:
Anticipated Entry Term:
Academic Programme:
Mode of Study:
Proposed research topic:
Proposed research supervisor:
Proposed research group:
Personal Details
First Name:
Last Name:
Gender:
Contact Details
Email Address:
Permanent Address Line 1:
Permanent Address Line 2:
Permanent Address City:
Permanent Address Country/State:
Permanent Address ZIP/Postal Code:
Academic Experience
Higher Education Institution
*Department Name (full or partial):
*University Name (full or partial):
*Country:
Additional Institutions:


Tramway Venture Partners
Investing in Life Science &
Health Care Companies
We are a highly experienced, locally based, nationally and internationally connected team that understands the challenges of making profitable seed and early stage investment in technology based companies in the southwest region


gridnode.cpp Example File
scenegraph/graph/gridnode.cpp/**************************************************************************** ** ** Copyright (C) 2015 The Qt Company Ltd. ** Contact: http://www.qt.io/licensing/ ** ** This file is part of the examples of the Qt Toolkit. ** ** $QT_BEGIN_LICENSE:BSD$ ** You may use this file under the terms of the BSD license as follows: ** ** "Redistribution and use in source and binary forms, with or without ** modification, are permitted provided that the following conditions are ** met: ** * Redistributions of source code must retain the above copyright ** notice, this list of conditions and the following disclaimer. ** * Redistributions in binary form must reproduce the above copyright ** notice, this list of conditions and the following disclaimer in ** the documentation and/or other materials provided with the ** distribution. ** * Neither the name of The Qt Company Ltd nor the names of its ** contributors may be used to endorse or promote products derived ** from this software without specific prior written permission.   ** ** $QT_END_LICENSE$ ** ****************************************************************************/ #include "gridnode.h" #include "qmath.h" #define GRID_SIZE 32 GridNode::GridNode() : m_geometry(QSGGeometry::defaultAttributes_Point2D(), 0) { setGeometry(&m_geometry); m_geometry.setDrawingMode(GL_LINES); setMaterial(&m_material); m_material.setColor(Qt::gray); } /* * The function hardcodes a fixed set of grid lines and scales * those to the bounding rect. */ void GridNode::setRect(const QRectF &rect) { int vCount = int((rect.width() - 1) / GRID_SIZE); int hCount = int((rect.height() - 1) / GRID_SIZE); int lineCount = vCount + hCount; QSGGeometry *g = geometry(); g->allocate(lineCount * 2); float x = rect.x(); float y = rect.y(); float w = rect.width(); float h = rect.height(); QSGGeometry::Point2D *v = g->vertexDataAsPoint2D(); // Then write the vertical lines for (int i=0; i<vCount; ++i) { float dx = (i + 1) * GRID_SIZE; v[i*2].set(dx, y); v[i*2+1].set(dx, y + h); } v += vCount * 2; // Then write the horizontal lines for (int i=0; i<hCount; ++i) { float dy = (i + 1) * GRID_SIZE; v[i*2].set(x, dy); v[i*2+1].set(x + w, dy); } // Tell the scenegraph we updated the geometry.. markDirty(QSGNode::DirtyGeometry); }


Base class for managing a static or dynamic buffer, used by both JsonParser and JsonWriter.
More...
#include <JsonParserGeneratorRK.h>
|
|
char * | buffer |
| | The buffer to to read from or write to. This is not null-terminated.
|
| |
|
size_t | bufferLen |
| | The length of the buffer in bytes,.
|
| |
|
size_t | offset |
| | The read or write offset.
|
| |
|
bool | staticBuffers |
| | True if the buffers were passed in and should not freed or reallocated.
|
| |
Base class for managing a static or dynamic buffer, used by both JsonParser and JsonWriter.
◆ JsonBuffer()
| JsonBuffer::JsonBuffer |
( |
char * |
buffer, |
|
|
size_t |
bufferLen |
|
) |
| |
Construct a JsonBuffer with an external buffer of a given size.
- Parameters
-
| buffer | Pointer to the buffer |
| bufferLen | The length of the buffer |
◆ addData()
| bool JsonBuffer::addData |
( |
const char * |
data, |
|
|
size_t |
dataLen |
|
) |
| |
Add a string to the end of the buffer.
- Parameters
-
| data | Pointer to the string bytes. Does not need to be null-terminated |
| dataLen | Length of the data in bytes. For UTF-8, this is the number of bytes, not characters! |
◆ addString()
| bool JsonBuffer::addString |
( |
const char * |
data | ) |
|
|
inline |
Add a c-string to the end of the buffer.
- Parameters
-
| data | Pointer to a c-string (null terminated). |
◆ allocate()
| bool JsonBuffer::allocate |
( |
size_t |
len | ) |
|
Allocate the buffer using malloc/realloc.
- Parameters
-
| len | The length of the buffer in bytes |
- Returns
- true if the allocation/reallocation was successful or false if there was not enough free memory.
There's also a version that takes a pointer and length to use a static buffer instead of a dynamically allocated one.
◆ clear()
| void JsonBuffer::clear |
( |
| ) |
|
Clears the current buffer for writing.
This only sets the offset to 0, it does not clear the bytes.
◆ getBuffer()
| char* JsonBuffer::getBuffer |
( |
| ) |
const |
|
inline |
Gets a pointer to the internal buffer.
Note: The internal buffer is not null-terminated!
◆ getBufferLen()
| size_t JsonBuffer::getBufferLen |
( |
| ) |
const |
|
inline |
Gets the current length of the buffer.
The buffer length is either the bufferLen passed to the constructor that takes a buffer and bufferLen or the length allocated using allocate(len).
The documentation for this class was generated from the following files:


Possible to restart Synergy via Applescript?
-
neilio
Is Synergy applescriptable?
I want to restart Synergy via Applescript so that I can get it to reload the Track Change Items folder.
-
Greg Hurrell
All Cocoa applications support basic Apple Scripting of this sort:
tell application "Synergy" to quit
(I've got some more complicated Apple Script support in Synergy Advance, but that's another story. I'm looking at ways to make this autorefresh anyway in Synergy Advance, because I can use Panther-only APIs which I can't use in Synergy Classic because it must run on Jaguar.)
Reply
This topic is now closed.


brglm: Bias Reduction in Binomial-Response Generalized Linear Models
Fit generalized linear models with binomial responses using either an adjusted-score approach to bias reduction or maximum penalized likelihood where penalization is by Jeffreys invariant prior. These procedures return estimates with improved frequentist properties (bias, mean squared error) that are always finite even in cases where the maximum likelihood estimates are infinite (data separation). Fitting takes place by fitting generalized linear models on iteratively updated pseudo-data. The interface is essentially the same as 'glm'. More flexibility is provided by the fact that custom pseudo-data representations can be specified and used for model fitting. Functions are provided for the construction of confidence intervals for the reduced-bias estimates.
Downloads:
Reverse dependencies:
Linking:
Please use the canonical form
https://CRAN.R-project.org/package=brglm
to link to this page.


JavaScript is disabled on your browser.
Skip navigation links
Overview
Package
Class
Tree
Deprecated
Index
Help
Prev
Next
Frames
No Frames
All Classes
A
B
C
D
E
G
I
L
M
N
O
P
R
S
T
A
accelerateAndDecelarate()
- Method in class titrail.mokei.shimmachi.commands.
SpeedControl
addTrack(Track)
- Method in interface titrail.mokei.shimmachi.railroad.
RailroadWiring
addTrack(Track)
- Method in class titrail.mokei.shimmachi.railroad.
RailroadWiringLogger
B
Boundary
- Interface in
titrail.mokei.shimmachi.main
C
changeSpeed(int, int)
- Method in interface titrail.mokei.shimmachi.railroad.
RailroadWiring
changeSpeed(Track, int)
- Method in interface titrail.mokei.shimmachi.railroad.
RailroadWiring
changeSpeed(int, int)
- Method in class titrail.mokei.shimmachi.railroad.
RailroadWiringLogger
changeSpeed(Track, int)
- Method in class titrail.mokei.shimmachi.railroad.
RailroadWiringLogger
changeSpeed(int)
- Method in interface titrail.mokei.shimmachi.railroad.
Track
changeSpeed(int)
- Method in class titrail.mokei.shimmachi.railroad.
TrackLogger
Commands
- Interface in
titrail.mokei.shimmachi.commands
CommandsBoundary
- Interface in
titrail.mokei.shimmachi.commands
createRailroadWiringLogger(int, boolean)
- Static method in class titrail.mokei.shimmachi.main.logger.
LoggerCreater
CuiCommandsBoundary
- Class in
titrail.mokei.shimmachi.commands.cui
CuiCommandsBoundary(DisplayControlBoundary, InputStream)
- Constructor for class titrail.mokei.shimmachi.commands.cui.
CuiCommandsBoundary
CuiCommandsBoundary(DisplayControlBoundary)
- Constructor for class titrail.mokei.shimmachi.commands.cui.
CuiCommandsBoundary
CuiDisplayControlBoundary
- Class in
titrail.mokei.shimmachi.commands.cui
CuiDisplayControlBoundary(PrintStream)
- Constructor for class titrail.mokei.shimmachi.commands.cui.
CuiDisplayControlBoundary
CuiDisplayControlBoundary()
- Constructor for class titrail.mokei.shimmachi.commands.cui.
CuiDisplayControlBoundary
CuiExitCommandsBoundary
- Class in
titrail.mokei.shimmachi.commands.cui
CuiExitCommandsBoundary(CuiCommandsBoundary)
- Constructor for class titrail.mokei.shimmachi.commands.cui.
CuiExitCommandsBoundary
CuiOperator
- Class in
titrail.mokei.shimmachi.commands.cui
CuiOperator(RailroadWiring, CuiCommandsBoundary)
- Constructor for class titrail.mokei.shimmachi.commands.cui.
CuiOperator
CuiSpeedControlBoundary
- Class in
titrail.mokei.shimmachi.commands.cui
CuiSpeedControlBoundary(CuiCommandsBoundary)
- Constructor for class titrail.mokei.shimmachi.commands.cui.
CuiSpeedControlBoundary
D
decideNewSpeed()
- Method in class titrail.mokei.shimmachi.commands.
SpeedControl
display()
- Method in class titrail.mokei.shimmachi.commands.
DisplayControl
DisplayControl
- Class in
titrail.mokei.shimmachi.commands
DisplayControl(RailroadWiring, DisplayControlBoundary)
- Constructor for class titrail.mokei.shimmachi.commands.
DisplayControl
DisplayControlBoundary
- Interface in
titrail.mokei.shimmachi.commands
E
exit()
- Method in class titrail.mokei.shimmachi.commands.
ExitCommands
ExitCommands
- Class in
titrail.mokei.shimmachi.commands
ExitCommands(ExitCommandsBoundary)
- Constructor for class titrail.mokei.shimmachi.commands.
ExitCommands
ExitCommandsBoundary
- Interface in
titrail.mokei.shimmachi.commands
G
getDisplay()
- Method in class titrail.mokei.shimmachi.commands.cui.
CuiCommandsBoundary
getInputStream()
- Method in class titrail.mokei.shimmachi.commands.cui.
CuiCommandsBoundary
I
inputNewSpeed()
- Method in class titrail.mokei.shimmachi.commands.cui.
CuiSpeedControlBoundary
inputNewSpeed()
- Method in interface titrail.mokei.shimmachi.commands.
SpeedControlBoundary
inputTrack()
- Method in class titrail.mokei.shimmachi.commands.cui.
CuiSpeedControlBoundary
inputTrack()
- Method in interface titrail.mokei.shimmachi.commands.
SpeedControlBoundary
isIn(int)
- Method in interface titrail.mokei.shimmachi.railroad.
RailroadWiring
isIn(Track)
- Method in interface titrail.mokei.shimmachi.railroad.
RailroadWiring
isIn(int)
- Method in class titrail.mokei.shimmachi.railroad.
RailroadWiringLogger
isIn(Track)
- Method in class titrail.mokei.shimmachi.railroad.
RailroadWiringLogger
isInRange(int)
- Method in interface titrail.mokei.shimmachi.railroad.
RailroadWiring
isInRange(int)
- Method in class titrail.mokei.shimmachi.railroad.
RailroadWiringLogger
L
LoggerCreater
- Class in
titrail.mokei.shimmachi.main.logger
LoggerCreater()
- Constructor for class titrail.mokei.shimmachi.main.logger.
LoggerCreater
M
Main
- Class in
titrail.mokei.shimmachi.main
Main()
- Constructor for class titrail.mokei.shimmachi.main.
Main
main(String[])
- Static method in class titrail.mokei.shimmachi.main.
Main
mainLoop()
- Method in class titrail.mokei.shimmachi.commands.cui.
CuiOperator
N
NOT_SUPPRESS_STDOUT_LOGGER
- Static variable in class titrail.mokei.shimmachi.main.logger.
LoggerCreater
O
operate()
- Method in interface titrail.mokei.shimmachi.commands.
Commands
operate()
- Method in class titrail.mokei.shimmachi.commands.
DisplayControl
operate()
- Method in class titrail.mokei.shimmachi.commands.
ExitCommands
operate()
- Method in class titrail.mokei.shimmachi.commands.
SpeedControl
P
printMessage(String)
- Method in interface titrail.mokei.shimmachi.commands.
CommandsBoundary
printMessage(String)
- Method in class titrail.mokei.shimmachi.commands.cui.
CuiCommandsBoundary
printMessage(String)
- Method in class titrail.mokei.shimmachi.commands.cui.
CuiDisplayControlBoundary
printMessage(String)
- Method in class titrail.mokei.shimmachi.commands.cui.
CuiExitCommandsBoundary
printMessage(String)
- Method in class titrail.mokei.shimmachi.commands.cui.
CuiSpeedControlBoundary
printStatus(RailroadWiring)
- Method in interface titrail.mokei.shimmachi.commands.
CommandsBoundary
printStatus(RailroadWiring)
- Method in class titrail.mokei.shimmachi.commands.cui.
CuiCommandsBoundary
printStatus(RailroadWiring)
- Method in class titrail.mokei.shimmachi.commands.cui.
CuiDisplayControlBoundary
printStatus(RailroadWiring)
- Method in class titrail.mokei.shimmachi.commands.cui.
CuiExitCommandsBoundary
printStatus(RailroadWiring)
- Method in class titrail.mokei.shimmachi.commands.cui.
CuiSpeedControlBoundary
printStatus(PrintStream)
- Method in interface titrail.mokei.shimmachi.railroad.
RailroadWiring
printStatus(PrintStream)
- Method in class titrail.mokei.shimmachi.railroad.
RailroadWiringLogger
printStatus(PrintStream)
- Method in interface titrail.mokei.shimmachi.railroad.
Track
printStatus(PrintStream)
- Method in class titrail.mokei.shimmachi.railroad.
TrackLogger
R
RailroadWiring
- Interface in
titrail.mokei.shimmachi.railroad
RailroadWiringLogger
- Class in
titrail.mokei.shimmachi.railroad
RailroadWiringLogger(Logger)
- Constructor for class titrail.mokei.shimmachi.railroad.
RailroadWiringLogger
RailroadWiringLogger(String)
- Constructor for class titrail.mokei.shimmachi.railroad.
RailroadWiringLogger
requireNewSpeed()
- Method in class titrail.mokei.shimmachi.commands.cui.
CuiSpeedControlBoundary
requireNewSpeed()
- Method in interface titrail.mokei.shimmachi.commands.
SpeedControlBoundary
requireTrack()
- Method in class titrail.mokei.shimmachi.commands.cui.
CuiSpeedControlBoundary
requireTrack()
- Method in interface titrail.mokei.shimmachi.commands.
SpeedControlBoundary
S
specifyTrack()
- Method in class titrail.mokei.shimmachi.commands.
SpeedControl
SpeedControl
- Class in
titrail.mokei.shimmachi.commands
SpeedControl(RailroadWiring, SpeedControlBoundary)
- Constructor for class titrail.mokei.shimmachi.commands.
SpeedControl
SpeedControlBoundary
- Interface in
titrail.mokei.shimmachi.commands
SUPPRESS_STDOUT_LOGGER
- Static variable in class titrail.mokei.shimmachi.main.logger.
LoggerCreater
T
titrail.mokei.shimmachi.commands
- package titrail.mokei.shimmachi.commands
titrail.mokei.shimmachi.commands.cui
- package titrail.mokei.shimmachi.commands.cui
titrail.mokei.shimmachi.main
- package titrail.mokei.shimmachi.main
titrail.mokei.shimmachi.main.logger
- package titrail.mokei.shimmachi.main.logger
titrail.mokei.shimmachi.railroad
- package titrail.mokei.shimmachi.railroad
Track
- Interface in
titrail.mokei.shimmachi.railroad
TrackLogger
- Class in
titrail.mokei.shimmachi.railroad
TrackLogger(Logger)
- Constructor for class titrail.mokei.shimmachi.railroad.
TrackLogger
TrackLogger(String)
- Constructor for class titrail.mokei.shimmachi.railroad.
TrackLogger
A
B
C
D
E
G
I
L
M
N
O
P
R
S
T
Skip navigation links
Overview
Package
Class
Tree
Deprecated
Index
Help
Prev
Next
Frames
No Frames
All Classes


A template blog post which I will use to create all future blog pages for my website.
An exploration into my identity, values, strengths, and weaknesses. What were some of the major influences to who I am today? What do I do well, and what do I struggle with. Come with me as I try to figure out who I 'really' am.
Struggling to understand the difference between padding and margins? Don't know why your borders aren't where you want them to be. Did adding margins mess up your whole layout? Check out my beginner CSS technical blog focusing on borders, padding, and margins.
This is where I lay out my Personal Learning Plan. What do I want to get out of studying at EDA? What do I expect from myself and the people who are around me? Read my expectations and commitments as I head off on my EDA journey.
Building a website is like building a house. Find out a little bit about how HTML, CSS, JavaScript, and the DOM help us turn plans into realities.
An introduction to Emotional Intelligence, the ability to understand and relate to other peoples' emotions. Learn the benefits and applications of developing your EQ and how it increases your performance, leadership skills, and chances of landing a job.
Building a website is like building a house. Find out a little bit about how HTML, CSS, JavaScript, and the DOM help us turn plans into realities.
An introduction to Emotional Intelligence, the ability to understand and relate to other peoples' emotions. Learn the benefits and applications of developing your EQ and how it increases your performance, leadership skills, and chances of landing a job.
After five weeks the Foundations course is coming to an end. Let's have a look at what I found easy, what I struggled with, annd what I have learnt along the way.


acclimation temperature performance test thermal capacity Xenopus tropicalis locomotor laevis burst {border-style Herrel animals force jump px;} #ffffff;} Biol Physiol = ., aquatic different species measured change climate Thermal effect effects higher traits However, Seebacher Wilson high Ecol acclimated frog individuals results acclimate compared lower response sex temperature, Exp accl. adult amphibians greater invasive temperature. temperatures tropical °C: Acclimation Angilletta Bonneaud Zool changes ectotherms endurance global model px; {font-family Animals Franklin amphibian anuran font-size studies using ./jeb. body climatic dependent double; exertion given impacts individual interaction maintained physiological terrestrial °C, ./j.-...x = .). Biochem Blaustein Bonneaud, Comp Feder Fig. France Funct James Miller Navas adults border-color border-width differences frogs impact interactions likely living low muscle range showed size solid; study suggested support temperate variability water {font-style {font-weight °C. (i.e. *test: Conserv Courant Limnodynastes Madeira National Rogers Van Vinagre a). ability anurans average bold closely containing context contrast, courier; daily dependence em; evolutionary example, explained frog, identity impacted lack latitude latitudes metabolism physiology plasticity ponds previous provide pt;} sex-specific showing single stamina tadpoles thermally tropicalis, variance


A variation of a shot taken for the promotional video -front-
A variation of a shot taken for the promotional video -side-
A variation of a shot taken for the promotional video -backside-


|
OR-Tools
7.1
Google Optimization software suite
|
#include <routing.h>
Public Member Functions | |
| CPFeasibilityFilter (const RoutingModel *routing_model) | |
| ~CPFeasibilityFilter () override | |
| std::string | DebugString () const override |
| bool | Accept (Assignment *delta, Assignment *deltadelta) override |
| void | OnSynchronize (const Assignment *delta) override |
| Public Member Functions inherited from operations_research::IntVarLocalSearchFilter | |
| IntVarLocalSearchFilter (const std::vector< IntVar * > &vars, Solver::ObjectiveWatcher objective_callback) | |
| IntVarLocalSearchFilter (const std::vector< IntVar * > &vars) | |
| ~IntVarLocalSearchFilter () override | |
| void | Synchronize (const Assignment *assignment, const Assignment *delta) override |
| bool | FindIndex (IntVar *const var, int64 *index) const |
| virtual void | InjectObjectiveValue (int64 objective_value) |
| void | AddVars (const std::vector< IntVar * > &vars) |
| int | Size () const |
| IntVar * | Var (int index) const |
| int64 | Value (int index) const |
| bool | IsVarSynced (int index) const |
| Public Member Functions inherited from operations_research::LocalSearchFilter | |
| virtual bool | IsIncremental () const |
| virtual int64 | GetSynchronizedObjectiveValue () const |
| virtual int64 | GetAcceptedObjectiveValue () const |
| Public Member Functions inherited from operations_research::BaseObject | |
| BaseObject () | |
| virtual | ~BaseObject () |
Additional Inherited Members | |
| Protected Member Functions inherited from operations_research::IntVarLocalSearchFilter | |
| void | SynchronizeOnAssignment (const Assignment *assignment) |
| bool | CanPropagateObjectiveValue () const |
| void | PropagateObjectiveValue (int64 objective_value) |
| Protected Attributes inherited from operations_research::IntVarLocalSearchFilter | |
| int64 | injected_objective_value_ |
|
explicit |
|
inlineoverride |
|
inlineoverridevirtual |
Reimplemented from operations_research::BaseObject.
|
overridevirtual |
Implements operations_research::LocalSearchFilter.
|
overridevirtual |
Reimplemented from operations_research::IntVarLocalSearchFilter.


| interested? | Owner | Origin | Destination | Date | Price | Availability |
|---|---|---|---|---|---|---|
| {{car.owner}} | {{car.from | uppercase}} | {{car.destination | uppercase}} | {{car.date | date:'fullDate'}} at {{car.time | date:'h:mma'}} | {{car.price | currency}} | {{car.availableSeats | number}} of {{car.seats | number}} Last seat |


World Terrorism Map
Use lasso to select interested area.
Data table
Click to column to select field and see field summary. Hold Alt and click to row to see event summary
Quick Summary


Fig. species prey model data seabird catch trophic {border-style fig. seabirds ecosystem px;} #ffffff;} marine North diet fish food models wing Pacific climate dependence high time CSIA-AA commercial plots stable foraging isotope used values Ecol. Mar. decline fisheries observed variable analysis catch, forage index loading series squid Biol. MTL Partial abundance estimates forest generated global large px; source surface using web {font-family Bayesian availability declines ensemble font-size goatfish mean mixing relationships relative sea set shifts study Hawaiian However, Proc. Prog. Sci. albatross amino area composition double; dynamics ecomorphology ecosystems fishery fishery-independent importance indicators jacks low metrics nitrogen ocean partial period predictors present random reflect regression relatively response shift trees use (fig. Laysan Oscillation S). SST Ser. border-color border-width broadly changes data, error fishing important individual interactions item management means pelagic reconstructed reveal shows solid; stomach structure suggest table taxa year {font-style {font-weight %), CSIA-AA–derived Christensen E). K.S.V.H. Nature PDO Pauly Random SAU Science Seabird Soc. Supplementary TP. TPs [], acids analyze available bold breeding brown calculated calendar central complex compound-specific conditional contents courier; credible data. declined dietary diets different dominant em; feathers groups high-TL historical indicate level long-term model, models. number oceanic period. plots. position predator predators provided pt;} reconstructions research results size status studies tissues track trends variety


Start the realtime face recognition stream
Add a new student here !!
Your captured image will appear here...


{# Copyright 2022 Google LLC Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. #} {%- extends BASE_HTML -%} {% set main_id = 'browser_landing' %} {% set page_id = 'page-browser_landing' %} {% set title = 'Graph Browser' %} {% set subpage_title = 'Graph Browser' %} {% set subpage_url = url_for('browser.browser_main') %} {% block head %} {% endblock %} {% block content %}
The Data Commons Graph is constructed by synthesizing a single database from many different data sources. This graph browser can be used both to explore what data is available and to understand the graph structure.
You can use the search box above or start looking around from some well known starting points:


Advisory
Labs
NUMURO
Insights
About
whatsapp
whatsapp
whatsapp
whatsapp
whatsapp
whatsapp
whatsapp
whatsapp
whatsapp
whatsapp


Here's a Horizontal Bar chart clearly indicating the 2016 UK referendum results. Let's not dwell on the disastrous nature of the vote though and look at the chart shall we?
It has a high marginInner
setting - though the bars are still quite thick
due to the height of the chart and the fact that there's only two values that are being
represented.
It uses the labelsAbove
setting, has tooltips
and the number of X axis
labels has been increased. The number of vertical background grid lines has been increased to match
the number of labels.
The responsive()
function reduces the size of the chart, the text that's on the chart,
slightly reduces the marginInner
and reduces the number of X axis labels that you see.
It also removes the CSS float
on the canvas tag.
And finally, it's animated using the grow()
effect - which is a linear growing effect.
<script src="RGraph.common.core.js"></script> <script src="RGraph.common.tooltips.js"></script> <script src="RGraph.common.dynamic.js"></script> <script src="RGraph.hbar.js"></script>Put this where you want the chart to show up:
<canvas id="cvs" width="600" height="275"> [No canvas support] </canvas>This is the code that generates the chart:


Intro info.

Use the gear icon in the upper right to come back here from the game


Copyright © 1970 W3C® (MIT, ERCIM, Keio, Beihang). W3C liability, trademark and permissive document license rules apply.
This specification defines UI Events which extend the DOM Event objects defined in [DOM]. UI Events are those typically implemented by visual user agents for handling user interaction such as mouse and keyboard input.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
The management and production of this document follows a relatively complex setup. Details are provided as part of the introduction.
This document was published by the Web Platform Working Group as a Working Draft. Feedback and comments on this specification are welcome. Please use GitHub issues Historical discussions can be found in the<EMAIL_ADDRESS>archives.
Publication as a Working Draft does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress.
This document was produced by a group operating under the W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.
This document is governed by the 1 March 2017 W3C Process Document.


Bouncy Particle Fun
Start
Stop
Particle Creator
Generate One Particle
Generate 50 Particles
Total KE:


--- title: My Credit Cards Betrayed me in Takayama, Japan date: 2018-12-12 hero_image: writing/takayama-hero.jpg hero_style: normal featured_image: writing/takayama.jpg medium_url: https://medium.com/@danrschlosser/my-credit-cards-betrayed-me-in-takayama-japan-576c24e3c713 ---
So there I was, standing in the middle of the street, when it hit me: I didn’t have enough money to afford my room that night. Or a bus ticket back to the city. I wasn’t even sure if I could afford dinner.
And with the strongest typhoon in 25 years about to make landfall in Osaka, I needed to figure something out. Like, now.


We've had a lot of requests from those interested in Aurelia to hear about and see apps, plugins and components built with Aurelia. This week, one of our Core Team authors and creators, Dwayne Charrington, has something cool to share...
Hello everyone! My name is Dwayne Charrington and I am a front-end developer and Aurelia author from sunny Queensland, Australia.
I have just launched a new Aurelia showcase site called Built With Aurelia with the simple goal of showcasing all of the great things the community is building with and for Aurelia. Over the last few months I have been observing the community discuss the great applications they are building. Many are asking for examples of Aurelia being used in the real world.
I love seeing what others have built and reading through code, so a showcase site that not only shows you what is possible to build with Aurelia, but also helps provide some free publicity to the community while coinciding with the recent release of Aurelia 1.0, seemed fitting.
The site itself is built using the Aurelia CLI, it is hosted on Github Pages and leverages Google's versatile Firebase platform. The site also allows you to vote up submissions (which requires creating a free account).
There are plenty of ideas on the wish list, so stay tuned as the site will be continually improved over the coming months. If you have built something with Aurelia or maybe a plugin/bridge, feel free to submit it to the site: self promotion is encouraged.
Kind regards, Dwayne Charrington
PS. Shameless plug: I am currently writing a publish-as-I-go book on Aurelia which you can grab over here at Leanpub if you are interested in learning more about developing with Aurelia. It is currently 76% complete.


General discussion about Komodo. For useful links and more info click the pinned messages to the right. DON'T DM @jl777
100 messages
Before 05-Dec-19 12:00 AM
FishyGuts19-Apr-19 12:40 PM
I prefer simple functioning solutions to problem.s
mrlynch19-Apr-19 12:40 PM
not with that attitude it isn't
i prefer simple solutions over unnecessary over-complications of things
jl777c19-Apr-19 12:40 PM
I prefer things that are working and allow others to make improvements and variations of it
FishyGuts19-Apr-19 12:40 PM
"LINK tokens are used to pay data providers, ChainLink node operators, payment providers, and other online service providers for their services. Smart contract users will compensate the data providers that they use with LINK tokens."
How's this working out. Curious.(edited)
jl777c19-Apr-19 12:41 PM
we are not
mrlynch19-Apr-19 12:41 PM
if you quantify quality in more lines of code you don't really understand efficiency(edited)
jl777c19-Apr-19 12:41 PM
dont worry komodo wont obsolete the LINK
FishyGuts19-Apr-19 12:41 PM
LOL True. KMD will probably benefit link in the future.
jl777c19-Apr-19 12:41 PM
but maybe the hundreds of trustless oracles chains made by others will put a dent
FishyGuts19-Apr-19 12:41 PM
@dane won't even know it.
Bye bird.
"As LINK tokens are used as a currency on the ChainLink platform, the more usage the ChainLink platform has, the more valuable LINK tokens should be."
mrlynch19-Apr-19 12:42 PM
and you expect ppl to take you seriously?! bye
FishyGuts19-Apr-19 12:42 PM
Nice promises from an ICO.
I think he is referring to your complete lack of substance.
Be happy to discuss real innovation and tech comparisions.

Sensitive bud.
blocking now. I have better things to work on than scraping my boot.
jl777c19-Apr-19 12:45 PM
so blockchains are redundant, we should get rid of them?
just use a centralized DB
1
FishyGuts19-Apr-19 12:46 PM
This is gonna read REAL weird with him blocked (edited)
jl777c19-Apr-19 12:46 PM
if you have to trust some other node, it is a trusted network but it can be very efficient
if you want a trustless network, it has to be less efficient, that removes the trust
Why are guys wasting time talking to us instead of coding?

Guess we're too busy building.
Sylvarant19-Apr-19 12:52 PM
This ^^^^
Fucking linkies
jl777c19-Apr-19 12:52 PM
Timo was cool
FishyGuts19-Apr-19 12:52 PM
100% Timo was
jl777c19-Apr-19 12:52 PM
the other... not so much
Timo19-Apr-19 12:53 PM
Oh boy, sorry for bringing people here. I really just wanted a healthy debate and I am really happy to had the discussion above. I don't have much time right now but I would be happy to continue tomorrow maybe. Sorry for the abrupt end. Thanks for you time guys!
9
Lamp19-Apr-19 12:53 PM
I don't think community members do the building of products FYI
FishyGuts19-Apr-19 12:53 PM
@Timo - James will be glad to have sdiscussions on these topics anytime/
jl777c19-Apr-19 12:53 PM
ok. eager to hear how you will corrupt the timestamp an hour ahead
We're building tech that does not exist in the market.
Lamp19-Apr-19 12:54 PM
Sure, but Smart Contract is (whom you're implying are here argueing instead of building)
jl777c19-Apr-19 12:54 PM
i didnt say nontech community members do the tech, i said that devs are part of the community
i am always open to learning
FishyGuts19-Apr-19 12:55 PM
Smart Contracts - Fine. Trolls... not neccesary.
jl777c19-Apr-19 12:55 PM
especially if there are any potential flaws.
1
but so far, it seems the flaws are not in the trustless oracle
FishyGuts19-Apr-19 12:56 PM
They must have missed the three day conversation with Zack, the founder of Veo, and dev for Aeternity/Augur.
But hey, who cares about roots right?
jl777c19-Apr-19 12:56 PM
and with enough work, maybe a complex reward, punishment, reputation system can solve all the practical issues, but i get stuck on the offchain betting which brings in magnitudes more funds for the attacker than entire chain value. how can you fight that? even with BTC it cant win against sustained 51% hashrate
mrlynch19-Apr-19 12:58 PM
Why are guys wasting time talking to us instead of coding? some say we code in our sleep.. or do we sleep?!
FishyGuts19-Apr-19 12:59 PM
I was up at 3AM working.
Went to be at 2 AM the night before. It's been about 8 hours of sleep over 2 days for this pirate.
So, yes we sleep, but not enough?
I need a sleep mode button like JL has.
I think @Exile13 pulled an all nighter for his project.
 Ultimately y’all are accelerating adoption for the space as a whole. I will be informing myself about Komodo! Thanks.
4
1
ComputerGenie 👴👴👴19-Apr-19 01:08 PM
I will be informing myself about Komodo!wishes people would do that before roasting it
5
5
Lamp19-Apr-19 01:12 PM
I think Timo is just intrigued as to how Komodo presented Chainlink as 'flawed' in their blog
Not an attack, more an open discussion
But anyway - enough of that
ComputerGenie 👴👴👴19-Apr-19 01:14 PM
@Lamp I have a 27" monitor (mounted vertically) and it took 4 screens to read his tweets that he posted before coming to ask questions(edited)
3
Lamp19-Apr-19 01:14 PM
It's obvious the oracle problem is an issue - will be interesting to see what solution is best fit
It's more interesting than all the 'networks' posting their unlimited TPS


DualPivotQuicksort Class
Dual-Pivot Quicksort algorithm.
This class implements the dual-pivot quicksort algorithm as presented in Vladimir Yaroslavskiy's paper.
Some improvements have been copied from Android's implementation.
Static Methods
Code void insertionSort_(List a, int left, int right, int compare(a, b)) #
static void insertionSort_(List a, int left, int right, int compare(a, b)) { for (int i = left + 1; i <= right; i++) { var el = a[i]; int j = i; while ((j > left) && (compare(a[j - 1], el) > 0)) { a[j] = a[j - 1]; j--; } a[j] = el; } }
Code void sort(List a, int compare(a, b)) #
Sorts all elements of the given list a
according to the given
compare
function.
The compare
function takes two arguments x
and y
and returns
-1 if x < y
,
0 if x == y
, and
1 if x > y
.
The function's behavior must be consistent. It must not return different results for the same values.
static void sort(List a, int compare(a, b)) { _doSort(a, 0, a.length - 1, compare); }
Code void sortRange(List a, int from, int to, int compare(a, b)) #
Sorts all elements in the range from
(inclusive) to to
(exclusive)
of the given list a
.
If the given range is invalid an "OutOfRange" error is raised. TODO(floitsch): do we want an error?
See sort
for requirements of the compare
function.
static void sortRange(List a, int from, int to, int compare(a, b)) { if ((from < 0) || (to > a.length) || (to < from)) { throw "OutOfRange"; } _doSort(a, from, to - 1, compare); }


F*.js
Case study: simply-typed lambda-calculus¶
FIXME (Cătălin)
Any way I could have imported the existing code here without duplicating it? Without a way to do this maintaining this document and keeping it consistent will be a nightmare.
We now look at a larger case study: proving the soundness of a type-checker for the simply-typed \(\lambda\)-calculus (STLC). If you’re not familiar with STLC, you can have a look at the Software Foundations book for a gentle introduction given by the textual explanations (you can ignore the Coq parts there). The formalization and proof here closely follows the one in Software Foundations. Our proofs are, however, shorter and much more readable than Coq proofs.
Syntax¶
We represent STLC types by the |fstar| inductive datatype ty
.
We consider Booleans as the only base type (TBool
). Function types
are represented by the TArrow
constructor taking two type arguments.
For instance we write TArrow TBool TBool
for the type of functions
taking a Boolean argument and returning a Boolean result. This would be
written as bool -> bool
in |fstar| syntax, and
\(\mathsf{bool} \to \mathsf{bool}\) in paper notation.
We represent the expressions of STLC by the datatype exp
.
Variables are represented as integer “names” decorated by the
constructor EVar
. Variables are “bound” by lambda abstractions
(EAbs
). For instance the identity function on Booleans is written
EAbs 0 TBool (EVar 0)
. In paper notation one would write this
function as \((\lambda x:\mathsf{bool}.~x)\). The type annotation on
the argument (TBool
) allows for very simple type-checking. We are
not considering type inference here, to keep things simple. The
expression that applies the identity function to the ETrue
constant
is written
(in paper notation \((\lambda x:\mathsf{bool}.~x)~\mathsf{true}\)).
The language also has a conditional construct (if-then-else). For instance, the Boolean “not” function can be written as
(in paper notation \(\lambda x:\mathsf{bool}.~\mathsf{if }~x~\mathsf{ then~false~else~true}\)).
Operational semantics¶
We define a standard small-step call-by-value interpreter for STLC. The
final result of successfully evaluating an expression is called a
value. We postulate that functions and the Boolean constants are
values by defining is_value
, a boolean predicate on expressions (a
total function):
The EAbs
, ETrue
, and EFalse
cases share the same
right-hand-side (true
), which is a way to prevent duplication in
definitions.
In order to give a semantics to function applications we define a
function subst x e e'
that substitutes x
with e
in e'
:
We traverse the expression and when we reach a variable (EVar x')
we
check whether this is the variable x
we want to substitute, and if
it is we replace it by e
. For lambda abstractions (EAbs x' t e1)
we only substitute inside the body e1
if x
and x'
are
different; if they are the same we leave the body unchanged. The reason
for this is that the x
in e1
is bound by the abstraction: it is
a new, local name that just happens to be spelled the same as some
global name x
. The global x
is no longer accessible in this
scope, since it is shadowed by the local x
. The other cases are
straightforward.
Note for experts: Because we will only reduce closed expressions, where all variables are bound by previous lambdas, we will only ever substitute closed expressionse
, and this naive definition of substitution is good enough. Substitution would become trickier to define or the representation of variables would have to change if we were considering the case wheree
, the expression replacing a variable in some other expression, may itself contain free variables.
Given the definition of values and of substitution we can now define a
small-step interpreter, as a function step
that takes an expression
e
and it either returns the expression to which e
reduces in a
single step, or it returns None
in case of an error (all errors in
this language are typing errors, and will be prevented statically by the
type system).
val step : exp -> Tot (option exp) let rec step e = match e with | EApp e1 e2 -> if is_value e1 then if is_value e2 then match e1 with | EAbs x t e' -> Some (subst x e2 e') | _ -> None else match (step e2) with | Some e2' -> Some (EApp e1 e2') | None -> None else (match (step e1) with | Some e1' -> Some (EApp e1' e2) | None -> None) | EIf e1 e2 e3 -> if is_value e1 then match e1 with | ETrue -> Some e2 | EFalse -> Some e3 | _ -> None else (match (step e1) with | Some e1' -> Some (EIf e1' e2 e3) | None -> None) | _ -> None
We execute an application expression EApp e1 e2
in multiple steps by
first reducing e1
to a value, then reducing e2
to a value
(following a call-by-value evaluation order), and if additionally
e1
is an abstraction EAbs x t e'
we continue by substituting
the formal argument x
by the actual argument e2
. If not we
signal a dynamic typing error (a non-functional value is applied to
arguments) by returning None
. For EIf e1 e2 e3
we first reduce
the guard e1
: if the guard reduces to true
then we continue with
e2
, if the guard reduces to false
we continue with e3
, and
if the guard reduces to something else (e.g. a function) we report a
dynamic typing error. The None -> None
cases simply propagate errors
to the top level.
let _ = assert (step (EApp (EAbs 0 TBool (EVar 0)) ETrue) = Some ETrue) let _ = assert (step (EApp ETrue ETrue) = None)
Type-checker¶
In order to assign a type to a term, we need to know what assumptions we should make about the types of its free variables. So typing happens with respect to a typing environment—a mapping from the variables in scope to their types. We represent such partial maps as functions taking an integer variable name and returning an optional type:
type env = int -> Tot (option ty)
We start type-checking closed terms in the empty environment, i.e. initially no variables are in scope.
val empty : env let empty = fun _ -> None
When we move under a binder we extend the typing environment.
val extend : env -> int -> ty -> Tot env let extend g x t = fun x' -> if x = x' then Some t else g x'
For instance we type-check EAbs x t e
in typing environment g
by
first type-checking the body e
in the environment extend g x t
.
The type-checker is a total function taking an environment g
and an
expression e
and producing either the type of e
or None
if
e
is not well-typed.
val typing : env -> exp -> Tot (option ty) let rec typing g e = match e with | EVar x -> g x | EAbs x t e1 -> (match typing (extend g x t) e1 with | Some t' -> Some (TArrow t t') | None -> None) | EApp e1 e2 -> (match typing g e1, typing g e2 with | Some (TArrow t11 t12), Some t2 -> if t11 = t2 then Some t12 else None | _ , _ -> None) | ETrue -> Some TBool | EFalse -> Some TBool | EIf e1 e2 e3 -> (match typing g e1, typing g e2, typing g e3 with | Some TBool, Some t2, Some t3 -> if t2 = t3 then Some t2 else None | _ , _ , _ -> None)
Variables are simply looked up in the environment. For abstractions
EAbs x t e1
we type-check the body e1
under the environment
extend g x t
, as explained above. If that succeeds and produces a
type t'
, then the whole abstraction is given type TArrow t t'
.
For applications EApp e1 e2
we type-check e1
and e2
separately, and if e1
has a function type TArrow t11 t12
and
e2
has type t11
, then the whole application has type t12
.
ETrue
and EFalse
have type TBool
. For conditionals, we
require that the guard has type TBool
and the two branches have the
same type, which is also the type of the conditional.
Soundness proof¶
FIXME (Cătălin)
I generally find giving people finished proofs uninformative and unhelpful.
This seems like something to do from scratch in an emacs buffer. Trying to capture that kind of interaction in the current format seems very hard.
We prove progress and preservation for STLC. The progress theorem tells us that closed, well-typed terms do not produce (immediate) dynamic typing errors: either a well-typed term is a value, or it can take an evaluation step. The proof is a relatively straightforward induction.
val progress : e:exp -> Lemma (requires (Some? (typing empty e))) (ensures (is_value e \/ (Some? (step e)))) let rec progress e = match e with | EApp e1 e2 -> progress e1; progress e2 | EIf e1 e2 e3 -> progress e1; progress e2; progress e3 | _ -> ()
Variables are not well-typed in the empty environment, so the theorem holds vacuously for variables. Boolean constants and abstractions are values, so the theorem holds trivially for these. All these simple cases are proved automatically by F★. For the remaining cases we need to use the induction hypothesis, but otherwise the proofs are fully automated. Under the hood F★ and Z3 are doing quite a bit of work though.
In case e = (EApp e1 e2)
F★ and Z3 automate the following intuitive
argument: We case split on the first instance of the induction
hypothesis (is_value e1 \/ (Some? (step e1)))
.
- If
e1
steps toe1'
then, by the definition ofstep
,(EApp e1 e2)
steps to(EApp e1' e2)
. - If
e1
is a value, we case split on the second induction hypothesis instance,(is_value e2 \/ (Some? (step e2)))
. - If
e2
steps toe2'
then(EApp e1 e2)
steps to(EApp e1 e2')
, sincee1
is a value. - If
e2
is also a value, then we need to obtain thate1
has a function type and from this that it is an abstraction. Expressione1
has a function type because, by the definition oftyping
, an application is well-typed only when the first expression is a function. The remaining step is usually done as a separate “canonical forms” lemma, stating that any value that has a function type is actually an abstraction. Z3 can prove this fact automatically from the definitions oftyping
andis_value
.
The intuitive proof of the EIf
case is similar.
The preservation theorem (sometimes also called “subject reduction”) states that when a well-typed expression takes a step, the result is a well-typed expression of the same type. In order to show preservation we need to prove a couple of auxiliary results for reasoning about variables and substitution.
The case for function application has to reason about “beta reduction”
steps, i.e. substituting the formal argument of a function with an
actual value. To see that this step preserves typing, we need to know
that the substitution itself does. So we prove a substitution lemma,
stating that substituting a (closed) term v
for a variable x
in
an expression e
preserves the type of e
. The tricky cases in the
substitution proof are the ones for variables and for function
abstractions. In both cases, we discover that we need to take an
expression e
that has been shown to be well-typed in some context
g
and consider the same expression e
in a slightly different
context g'
. For this we prove a context invariance lemma,
showing that typing is preserved under “inessential changes” to the
context g
—in particular, changes that do not affect any of the free
variables of the expression. For this, we need a definition of the free
variables of an expression—i.e., the variables occurring in the
expression that are not bound by an abstraction.
A variable x
appears free in e
if e
contains some occurrence
of x
that is not under an abstraction labeled x
:
val appears_free_in : x:int -> e:exp -> Tot bool let rec appears_free_in x e = match e with | EVar y -> x = y | EApp e1 e2 -> appears_free_in x e1 || appears_free_in x e2 | EAbs y _ e1 -> x <> y && appears_free_in x e1 | EIf e1 e2 e3 -> appears_free_in x e1 || appears_free_in x e2 || appears_free_in x e3 | ETrue | EFalse -> false
We also need a technical lemma connecting free variables and typing
contexts. If a variable x
appears free in an expression e
, and
if we know that e
is well typed in context g
, then it must be
the case that g
assigns some type to x
.
val free_in_context : x:int -> e:exp -> g:env -> Lemma (requires (Some? (typing g e))) (ensures (appears_free_in x e ==> Some? (g x))) let rec free_in_context x e g = match e with | EVar _ | ETrue | EFalse -> () | EAbs y t e1 -> free_in_context x e1 (extend g y t) | EApp e1 e2 -> free_in_context x e1 g; free_in_context x e2 g | EIf e1 e2 e3 -> free_in_context x e1 g; free_in_context x e2 g; free_in_context x e3 g
The proof is a straightforward induction. As a corollary for
g == empty
we obtain that expressions typable in the empty
environment have no free variables.
val typable_empty_closed : x:int -> e:exp -> Lemma (requires (Some? (typing empty e))) (ensures (not(appears_free_in x e))) [SMTPat (appears_free_in x e)] let typable_empty_closed x e = free_in_context x e empty
The quantifier pattern [SMTPat (appears_free_in x e)]
signals to Z3
that it should consider applying this lemma when its context contains a
term of the form appears_free_in
Sometimes, we know that typing g e = Some t
, and we will need to
replace g
by an “equivalent” context g'
. We still need to define
formally when two environments are equivalent. A natural definition is
extensional equivalence of functions:
logic type equal (g1:env) (g2:env) = forall (x:int). g1 x = g2 x
According to this definition two environments are equivalent if have the
same domain and they map all variables in the domain to the same type.
We remark equal
in particular and logical formulas in general are
types in F★, thus the different syntax for this definition.
FIXME (Cătălin)
What does opaque do exactly? What does logic do? Hints for the SMT solver / logical encoding only?
The context invariance lemma uses in fact a weaker variant of this
equivalence in which the two environments only need to agree on the
variables that appear free in an expression e
:
logic type equalE (e:exp) (g1:env) (g2:env) = forall (x:int). appears_free_in x e ==> g1 x = g2 x
The context invariance lemma is then easily proved by induction:
val context_invariance : e:exp -> g:env -> g':env -> Lemma (requires (equalE e g g')) (ensures (typing g e == typing g' e)) let rec context_invariance e g g' = match e with | EAbs x t e1 -> context_invariance e1 (extend g x t) (extend g' x t) | EApp e1 e2 -> context_invariance e1 g g'; context_invariance e2 g g' | EIf e1 e2 e3 -> context_invariance e1 g g'; context_invariance e2 g g'; context_invariance e3 g g' | _ -> ()
Because equal
is a stronger relation than equalE
we obtain the
same property for equal
:
val typing_extensional : g:env -> g':env -> e:exp -> Lemma (requires (equal g g')) (ensures (typing g e == typing g' e)) let typing_extensional g g' e = context_invariance e g g'
We can use these results to show the following substitution lemma:
val substitution_preserves_typing : x:int -> e:exp -> v:exp -> g:env -> Lemma (requires (Some? (typing empty v) /\ Some? (typing (extend g x (Some?.v (typing empty v))) e))) (ensures (Some? (typing empty v) /\ typing g (subst x v e) == typing (extend g x (Some?.v (typing empty v))) e)) let rec substitution_preserves_typing x e v g = let Some t_x = typing empty v in let gx = extend g x t_x in match e with | ETrue -> () | EFalse -> () | EVar y -> if x=y then context_invariance v empty g (* uses lemma typable_empty_closed *) else context_invariance e gx g | EApp e1 e2 -> substitution_preserves_typing x e1 v g; substitution_preserves_typing x e2 v g | EIf e1 e2 e3 -> substitution_preserves_typing x e1 v g; substitution_preserves_typing x e2 v g; substitution_preserves_typing x e3 v g | EAbs y t_y e1 -> let gxy = extend gx y t_y in let gy = extend g y t_y in if x=y then typing_extensional gxy gy e1 else (let gyx = extend gy x t_x in typing_extensional gxy gyx e1; substitution_preserves_typing x e1 v gy)
The proof proceeds by induction on the expression e
; we give the
intuition of the two most interesting cases:
Case
e = EVar y
Case
x = y
: We havesubst x v e = v
and we already know thattyping empty v == Some t_x
. However, what we need to show istyping g v == Some t_x
for some arbitrary environmentg
. From thetypable_empty_closed
lemma we obtain thatv
contains no free variables, so we haveequalE v empty g
. This allows us to apply thecontext_invariance
lemma to obtain thattyping empty v = typing g v
and complete the proof of this case.Case
x <> y
We havesubst x v e = e
andtyping gx e = Some t_e
and need to show thattyping g e == Some t_e
We have that
EquivE (EVar y) gx g
sincex <> y
so we can apply thecontext_invariance
lemma to conclude.Case
e = EAbs y t_y e1
: We have thattyping gxy e1 = Some t_e1
, and need to show thattyping gy e1 == Some t_e1
Case
x = y
We havesubst x v e = EAbs y t_y e1
. Sincex = y
thex
binder ingxy
is spurious (we haveequal gy gxy
) and can apply thetyping_extensional
lemma.Case
x <> y
We havesubst x v e = EAbs y t_y (subst x v e1)
. Sincex <> y
(and since we are in a simply typed calculus, not a dependently typed one) we can swap thex
andy
binding to show thatequal gxy xyx
. By thetyping_extensional
lemma we obtain thattyping gxy e1 == typing gyx e1
. By the induction hypothesis we thus obtain thattyping gy (subst x v e1) == Some t_e1
and by the definition of
typing
we conclude thattyping g (EAbs y t_y (subst x v e)) = t_e
.
We now have the tools we need to prove preservation: if a closed
expression e
has type t
and takes an evaluation step to e'
,
then e'
is also a closed expression with type t
. In other words,
the small-step evaluation relation preserves types.
val preservation : e:exp -> Lemma (requires (Some? (typing empty e) /\ Some? (step e) )) (ensures (Some? (step e) /\ typing empty (Some?.v (step e)) == typing empty e)) let rec preservation e = match e with | EApp e1 e2 -> if is_value e1 then (if is_value e2 then let EAbs x _ ebody = e1 in substitution_preserves_typing x ebody e2 empty else preservation e2) else preservation e1 | EIf e1 _ _ -> if not (is_value e1) then preservation e1
We only have two cases to consider, since only applications and
conditionals can take successful execution steps. The case for
e = EIf e1 e2 e3
is simple: either e1
is a value and thus the
conditional reduces to e2
or e3
which by the typing hypothesis
also have type t
, or e1
takes a successful step and we can apply
the induction hypothesis. We use the Some?.v
projector, which
requires F★ to prove that indeed e1
can take a step; this is
immediate since we know that the whole conditional takes a step and we
know that e1
is not a value.
The case for e = EApp e1 e2
is a bit more complex. If e1
steps
or if e1
is a value and e2
steps then we just apply the
induction hypothesis. If both e1
and e2
are values it needs to
be the case that e1
is an abstraction EAbs x targ ebody
and
step e = subst x e2 ebody
. From the typing assumption we have
typing (extend empty x tags) ebody = Some t
and
typing empty e2 = Some targ
, so we can use the substitution lemma to
obtain that typing empty (subst x e2 ebody) = Some t
, which
concludes the proof.
Exercises for STLC¶
Define a typed_step
step function that takes a well-typed expression
e
that is not a value and produces the expression to which e
steps. Give typed_step
the following strong type (basically this
type captures both progress and preservation):
val typed_step : e:exp{Some? (typing empty e) /\ not(is_value e)} -> Tot (e':exp{typing empty e' = typing empty e})
(Hint: the most direct solution to this exercise fits on one line)
let typed_step e = progress e; preservation e; Some?.v (step e)
To add pairs to this formal development we add the following to the definition of types, expressions, values, substitution, and step:
type tyP = (* {{{ 2 unchanged cases omitted *) | TBoolP : tyP | TArrowP : tin:tyP -> tout:tyP -> tyP (* }}} *) | TPairP : tyP -> tyP -> tyP type expP = (* {{{ 6 unchanged cases omitted *) | EVarP : v:var -> expP | EAppP : fn:expP -> arg:expP -> expP | EAbsP : v:var -> vty:tyP -> body:expP -> expP | ETrueP : expP | EFalseP : expP | EIfP : test:expP -> btrue:expP -> bfalse:expP -> expP (* }}} *) | EPairP : expP -> expP -> expP | EFstP : expP -> expP | ESndP : expP -> expP let rec is_valueP e = (* Note the extra let rec! *) match e with (* {{{ 3 unchanged cases omitted *) | EAbsP _ _ _ | ETrueP | EFalseP -> true (* }}} *) | EPairP e1 e2 -> is_valueP e1 && is_valueP e2 | _ -> false let rec substP x e e' = match e' with (* {{{ 6 unchanged cases omitted *) | EVarP x' -> if x = x' then e else e' | EAbsP x' t e1 -> EAbsP x' t (if x = x' then e1 else (substP x e e1)) | EAppP e1 e2 -> EAppP (substP x e e1) (substP x e e2) | ETrueP -> ETrueP | EFalseP -> EFalseP | EIfP e1 e2 e3 -> EIfP (substP x e e1) (substP x e e2) (substP x e e3) (* }}} *) | EPairP e1 e2 -> EPairP (substP x e e1) (substP x e e2) | EFstP e1 -> EFstP (substP x e e1) | ESndP e1 -> ESndP (substP x e e1) let rec stepP e = match e with (* {{{ 2 unchanged cases omitted *) | EAppP e1 e2 -> if is_valueP e1 then if is_valueP e2 then match e1 with | EAbsP x t e' -> Some (substP x e2 e') | _ -> None else match (stepP e2) with | Some e2' -> Some (EAppP e1 e2') | None -> None else (match (stepP e1) with | Some e1' -> Some (EAppP e1' e2) | None -> None) | EIfP e1 e2 e3 -> if is_valueP e1 then match e1 with | ETrueP -> Some e2 | EFalseP -> Some e3 | _ -> None else (match (stepP e1) with | Some e1' -> Some (EIfP e1' e2 e3) | None -> None) (* }}} *) | EPairP e1 e2 -> if is_valueP e1 then if is_valueP e2 then None else (match (stepP e2) with | Some e2' -> Some (EPairP e1 e2') | None -> None) else (match (stepP e1) with | Some e1' -> Some (EPairP e1' e2) | None -> None) | EFstP e1 -> if is_valueP e1 then (match e1 with | EPairP v1 v2 -> Some v1 | _ -> None) else (match (stepP e1) with | Some e1' -> Some (EFstP e1') | None -> None) | ESndP e1 -> if is_valueP e1 then (match e1 with | EPairP v1 v2 -> Some v2 | _ -> None) else (match (stepP e1) with | Some e1' -> Some (ESndP e1') | None -> None) | _ -> None
Add cases to typingP
for the new constructs and fix all the proofs.
We extend the typingP
and appears_free_inP
functions with cases
for EPairP
, EFstP
, and ESndP
:
type envP = int -> Tot (option tyP) val emptyP : envP let emptyP = fun _ -> None
When we move under a binder we extend the typing environment.
val extendP : envP -> int -> tyP -> Tot envP let extendP g x t = fun x' -> if x = x' then Some t else g x' val typingP : envP -> expP -> Tot (option tyP) let rec typingP g e = match e with (* {{{ 6 unchanged cases omitted *) | EVarP x -> g x | EAbsP x t e1 -> (match typingP (extendP g x t) e1 with | Some t' -> Some (TArrowP t t') | None -> None) | EAppP e1 e2 -> (match typingP g e1, typingP g e2 with | Some (TArrowP t11 t12), Some t2 -> if t11 = t2 then Some t12 else None | _ , _ -> None) | ETrueP -> Some TBoolP | EFalseP -> Some TBoolP | EIfP e1 e2 e3 -> (match typingP g e1, typingP g e2, typingP g e3 with | Some TBoolP, Some t2, Some t3 -> if t2 = t3 then Some t2 else None | _ , _ , _ -> None) (* }}} *) | EPairP e1 e2 -> (match typingP g e1, typingP g e2 with | Some t1, Some t2 -> Some (TPairP t1 t2) | _ , _ -> None) | EFstP e1 -> (match typingP g e1 with | Some (TPairP t1 t2) -> Some t1 | _ -> None) | ESndP e1 -> (match typingP g e1 with | Some (TPairP t1 t2) -> Some t2 | _ -> None) val appears_free_inP : x:int -> e:expP -> Tot bool let rec appears_free_inP x e = match e with (* {{{ 6 unchanged cases omitted *) | EVarP y -> x = y | EAppP e1 e2 -> appears_free_inP x e1 || appears_free_inP x e2 | EAbsP y _ e1 -> x <> y && appears_free_inP x e1 | EIfP e1 e2 e3 -> appears_free_inP x e1 || appears_free_inP x e2 || appears_free_inP x e3 | ETrueP | EFalseP -> false (* }}} *) | EPairP e1 e2 -> appears_free_inP x e1 || appears_free_inP x e2 | EFstP e1 -> appears_free_inP x e1 | ESndP e1 -> appears_free_inP x e1
The proofs of the lemmas are also easy to extend by just calling the induction hypothesis:
val free_in_contextP : x:int -> e:expP -> g:envP -> Lemma (requires (Some? (typingP g e))) (ensures (appears_free_inP x e ==> Some? (g x))) let rec free_in_contextP x e g = match e with (* {{{ 6 unchanged cases omitted *) | EVarP _ | ETrueP | EFalseP -> () | EAbsP y t e1 -> free_in_contextP x e1 (extendP g y t) | EAppP e1 e2 -> free_in_contextP x e1 g; free_in_contextP x e2 g | EIfP e1 e2 e3 -> free_in_contextP x e1 g; free_in_contextP x e2 g; free_in_contextP x e3 g (* }}} *) | EPairP e1 e2 -> free_in_contextP x e1 g; free_in_contextP x e2 g | EFstP e1 | ESndP e1 -> free_in_contextP x e1 g logic type equalEP (e:expP) (g1:envP) (g2:envP) = forall (x:int). appears_free_inP x e ==> g1 x = g2 x val context_invarianceP : e:expP -> g:envP -> g':envP -> Lemma (requires (equalEP e g g')) (ensures (typingP g e == typingP g' e)) let rec context_invarianceP e g g' = match e with (* {{{ 3 unchanged cases omitted *) | EAbsP x t e1 -> context_invarianceP e1 (extendP g x t) (extendP g' x t) | EAppP e1 e2 -> context_invarianceP e1 g g'; context_invarianceP e2 g g' | EIfP e1 e2 e3 -> context_invarianceP e1 g g'; context_invarianceP e2 g g'; context_invarianceP e3 g g' (* }}} *) | EPairP e1 e2 -> context_invarianceP e1 g g'; context_invarianceP e2 g g' | EFstP e1 | ESndP e1 -> context_invarianceP e1 g g' | _ -> () (* {{{ similar definitions skipped *) logic type equalP (g1:envP) (g2:envP) = forall (x:int). g1 x = g2 x val typing_extensionalP : g:envP -> g':envP -> e:expP -> Lemma (requires (equalP g g')) (ensures (typingP g e == typingP g' e)) let typing_extensionalP g g' e = context_invarianceP e g g' val typable_empty_closedP : x:int -> e:expP -> Lemma (requires (Some? (typingP emptyP e))) (ensures (not(appears_free_inP x e))) [SMTPat (appears_free_inP x e)] let typable_empty_closedP x e = free_in_contextP x e emptyP (* }}} *) val substitution_preserves_typingP : x:int -> e:expP -> v:expP -> g:envP -> Lemma (requires (Some? (typingP emptyP v) /\ Some? (typingP (extendP g x (Some?.v (typingP emptyP v))) e))) (ensures (Some? (typingP emptyP v) /\ typingP g (substP x v e) == typingP (extendP g x (Some?.v (typingP emptyP v))) e)) let rec substitution_preserves_typingP x e v g = (* {{{ unchanged preamble skipped *) let Some t_x = typingP emptyP v in let gx = extendP g x t_x in match e with | ETrueP -> () | EFalseP -> () | EVarP y -> if x=y then context_invarianceP v emptyP g (* uses lemma typable_empty_closed *) else context_invarianceP e gx g | EAppP e1 e2 -> substitution_preserves_typingP x e1 v g; substitution_preserves_typingP x e2 v g | EIfP e1 e2 e3 -> substitution_preserves_typingP x e1 v g; substitution_preserves_typingP x e2 v g; substitution_preserves_typingP x e3 v g | EAbsP y t_y e1 -> let gxy = extendP gx y t_y in let gy = extendP g y t_y in if x=y then typing_extensionalP gxy gy e1 else (let gyx = extendP gy x t_x in typing_extensionalP gxy gyx e1; substitution_preserves_typingP x e1 v gy) (* }}} *) | EPairP e1 e2 -> (substitution_preserves_typingP x e1 v g; substitution_preserves_typingP x e2 v g) | EFstP e1 | ESndP e1 -> substitution_preserves_typingP x e1 v g | _ -> ()
As for the other cases, the preservation proof when e = EPair e1 e2
follows the structure of the step
function. If e1
is not a value
then it further evaluates, so we apply the induction hypothesis to
e1
. If e1
is a value, then since we know that the pair
evaluates, it must be the case that e2
is not a value and further
evaluates, so we apply the induction hypothesis to it. The cases for
EFst
and ESnd
are similar.
val preservationP : e:expP{Some? (typingP emptyP e) /\ Some? (stepP e)} -> Tot (u:unit{typingP emptyP (Some?.v (stepP e)) == typingP emptyP e}) let rec preservationP e = match e with (* {{{ two unchanged cases *) | EAppP e1 e2 -> if is_valueP e1 then (if is_valueP e2 then let EAbsP x _ ebody = e1 in substitution_preserves_typingP x ebody e2 emptyP else preservationP e2) else preservationP e1 | EIfP e1 _ _ -> if not (is_valueP e1) then preservationP e1 (* }}} *) | EPairP e1 e2 -> (match is_valueP e1, is_valueP e2 with | false, _ -> preservationP e1 | true , false -> preservationP e2) | EFstP e1 | ESndP e1 -> if not (is_valueP e1) then preservationP e1
We want to add a let construct to this formal development. We add the following to the definition of expressions:
type exp =
...
| ELet : int -> exp -> exp -> exp
Add cases for ELet
to all definitions and proofs.
FIXME (Cătălin)
Make the prev kind of link a macro of some sorts. It doesn’t have a proper body so it’s not an environment, but what is it? Entity?
Define a big-step interpreter for STLC as a recursive function eval
that given a well-typed expression e
either produces the well-typed
value v
to which e
evaluates or it diverges if the evaluation of
e
loops. Give eval
the following strong type ensuring that v
has the same type as e
(basically this type captures both progress
and preservation):
val eval : e:exp{Some? (typing empty e)} -> Dv (v:exp{is_value v && typing empty v = typing empty e})
The Dv
effect is that of potentially divergent computations. We
cannot mark this as Tot
since a priori STLC computations could
loop, and it is hard to prove that well-typed ones don’t.
Here is a solution that only uses typed_step
(suggested by Santiago
Zanella):
let rec eval e = if is_value e then e else eval (typed_step e)
or using the progress
and preservation
lemmas instead of
typed_step
(suggested by Guido Martinez):
val eval' : e:exp{Some? (typing empty e)} -> Dv (v:exp{is_value v && typing empty v = typing empty e}) let rec eval' e = match step e with | None -> progress e; e | Some e' -> preservation e; eval' e'
Here is another solution that only uses the substitution lemma:
val eval'' : e:exp{Some? (typing empty e)} -> Dv (v:exp{is_value v && typing empty v = typing empty e}) let rec eval'' e = let Some t = typing empty e in match e with | EApp e1 e2 -> (let EAbs x _ e' = eval' e1 in let v = eval' e2 in substitution_preserves_typing x e' v empty; eval'' (subst x v e')) | EAbs _ _ _ | ETrue | EFalse -> e | EIf e1 e2 e3 -> (match eval'' e1 with | ETrue -> eval'' e2 | EFalse -> eval'' e3)


World's Billionaires Losing Trust in Banks?
The highest-earning big shots hardly appear to be cherishing much hope for hefty returns in 2020, especially following marked wealth dips in 2018.
According to a new survey conducted by UBS Global Wealth Management and cited by Bloomberg, at least a quarter of the most wealthy's savings is stored in cash, judging by data obtained from well over 3,400 global respondents.
The edition also noted that a majority of the richest investors expect a significant drop in markets before the end of next year.
The US-China trade standoff was named as their top geopolitical concern, while the upcoming American presidential election slated for 2020 is universally deemed as another significant threat to investors’ portfolios, the survey found.
A lion’s share of respondents – about four-fifths – believe that volatility is likely to increase, while predicting a feasible market sell-off just before the end of 2020.
“The rapidly changing geopolitical environment is the biggest concern for investors around the world”, summed up Paula Polito, client strategy officer at UBS GWM, in a statement.
“They see global interconnectivity and reverberations of change impacting their portfolios more than traditional business fundamentals, a marked change from the past”, she concluded.
It was reported in early November that the wealth of top tycoons around the world had shown a downward trend, falling by a little over 4 percent in 2018. Asia-Pacific billionaires suffered the most – they went down in number by 7.4 percent and their wealth decreased by 8 percent.


~PASSWORD GENERATOR~
🔥Create Your Password!🔥
Please Check All Boxes!
Number Of Characters
Please Include Uppercase
Please Include Numbers
Please Include Symbols
Generate Password


ANNE FRANK REMEMBERED A film review by Mark R. Leeper Copyright 1996 Mark R. Leeper
Capsule: This documentary contains just about all that is known about Anne Frank and her diary that one cannot get from the diary itself. After having been a best-seller, a popular play, and a film there is little need to replay the contents of the diary in more than a superficial manner. Jon Blair's account tells us fairly completely the rest of the story. There are, thank goodness, a decent number of documentaries about the Holocaust, but this one does one of the best jobs of bringing the events down to human terms--precisely the virtue that the diary had. Anne Frank is presented not as a saint but as a human with faults. This film won the Academy Award for Best Feature-length Documentary for very good reason. Rating: +3 (-4 to +4)
When I write a review of a film, particularly a historical film, I often try to give context for the story in the film. I try to create a frame to surround the film telling many of the incidental things that would be of interest to a viewer. That is what the feature-length documentary ANNE FRANK REMEMBERED does for the book THE DIARY OF ANNE FRANK and its dramatic adaptations. It generally assumes that the viewer has read or seen some version of the true story of the Jewish family that hid from the Nazis for two years in the cramped attic of an Amsterdam factory. Instead of having extensive excerpts from the book, this account tells the viewer nearly everything else of value to someone who is experiencing the story. It starts with the background of the Frank family, their lives and especially their times. Anecdotes are told of Anne's school experiences. The film tells how the Frank family went into hiding and gives a quick summary of their lives those two years in the stifling attic. There Anne's closest confidant was the diary she had been given on her 13th birthday. After telling how the family was betrayed and captured it goes into detail about their lives and the lives of people they knew in the camps. It tells of the death of Anne Frank and her sister. The liberation, the re-discovery of the diary, its publishing, public reaction, the play the film, and authenticity challenges are all covered. This is everything known about the story Anne Frank and her diary that one cannot get from the book itself.
Jon Blair, who previously made the documentary SCHINDLER, had to be not just skillful but extraordinarily lucky to find some of the material presented. Details about Anne and her personal life are presented by Hanneli Goslar, Anne's friend from age four. They were separated by Anne's hiding, but she coincidentally was able to find Anne when they both were interned at Bergen-Belsen concentration camp and was nearby when Anne died. One interview brings out the mixed emotions toward Anne of Peter Pepper, the son of the dentist who shared Anne's hiding place and whom Anne dubbed Dr. Idiot. During the period of hiding Anne seemed to conflict with every adult in the attic except her beloved father and these conflicts seem to make her even more real. Blair is even able to interview one of the burglars who preyed on the factory below the attic. In Anne's accounts of these incidents the Franks could do nothing but wait in silence for the criminals to leave for fear of letting be known their presence. The one major question that Blair must leave unanswered is who it was who eventually betrayed the hiding place of the Frank family.
Blair recreates in harrowing detail the life that Anne must have led in the camps and the fates of the people who hid in the attic. Only Otto Frank survived, but there is information and eyewitness accounts of what happened to most of the people from the attic. Blair documents how Anne's spirit was broken as she went from Westerbrook to Auschwitz to her death from disease at Bergen-Belsen. Blair speculates that had she held on to that spirit she could have survived the month between her death and liberation.
Blair mixes 1940s footage with material he shot and interviews with people who are now dead. Some of the people he brought together for the first time since the 1940s. The film is narrated by Kenneth Branagh and selections are read from the diary by Glenn Close. While the photography is mostly understated, there is occasionally a haunting image in the photography. One shot makes the tower over the railroad entrance to Auschwitz look extraordinarily like the head of some giant ogre with glowing eyes from some fairy tale that could not match for violence what actually took place here.
I suppose I would rate ANNE FRANK REMEMBERED a +3 on the -4 to +4 scale, though I have not given it the same sort of thought I usually give a rating. I take the subject of the Holocaust very seriously and would have a very hard time objectively comparing this film to, say, RICHARD III or THE GODFATHER.
Mark R. Leeper<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