avian viral species virus viruses host OpenUrl Fig virome S). diversity using CrossRef Anseriformes identified abundance different (Fig genera influenza Australian RNA wild number related Duck Grey Charadriiformes Pink-eared described genus phylogenetic study libraries shared tree Science Web alpha differences presented viromes IAV Teal composition connectivity hosts multi-host shown Red-necked analysis birds families likely Host Stint contigs family level library novel previously S-S). closely detected new significant species, structure Anseriform Figure Viruses acid amino dynamics ecology genomes heterogeneity including key members reads sampled scale species. taxonomic >;% (Table Bootstrap DNA Open Shelduck bar bird clustering containing data ducks filled indicates large nodes. prevalence revealed substitutions values Abstract Anas Charadriiformes, Download IAV, Influenza Wille avulavirus calculated compared complete data-hide-link-title=""> data-icon-position="" figure highly marked relationship rotavirus tab transmission variation vertebrate viruses. waterfowl Abundance Avian Evol. FREE Phylogenetic RdRp, Text birds. central clade clarity demonstrating did discordance disease duck example, family, feeding gene infection isolated lack levels library. limited low lower midpoint only. package pathogenic relationships retroviruses rooted sequences similar taxonomy used virus, (i.e. Anseriformes, Australia. Black Charadriiform Ducks Group Hepatitis Novel Pacific RdRp Sci Specifically, Teal, Wood abundance, adjacent calicivirus, communities distantly form generated high immune migratory orders picornaviruses potentially protein reference sampling share single-stranded sister specificity statistically suggesting taxonomically (A) (B) (Grey .%, ;<;div =., Charadriiformes. Chen Ecology Effects Finally, Given Holmes However, Infect ONE. Overall, Picornaviridae, Sharp-tailed Table Virol. Virome Virus Waldenström albeit alignment associated bacterial bold, bold. circle circle. clear composition. coronaviruses determine df=, dissimilarity divergent ecological factors gammacoronavirus genome hosts, illustrating indicate infected interactions libraries, model order partial patterns phylogeny picobirnavirus pictogram polyprotein, relative reservoirs respectively) role sequence short site. site.<;/div>;<;/div>;" support tested total type unassigned


{% extends "numbas_lti/management/base.html" %} {% load percentage %} {% load i18n %} {% block management_content %} {% if resource.attempts.count %}
{{resource.attempts.count}} {% blocktrans count counter=resource.attempts.count %}attempt{% plural %}attempts{% endblocktrans %} {% trans "by" %} {{students.count}} {% blocktrans count counter=students.count %}student{% plural %}students{% endblocktrans %}.
{% trans "Scores are currently being reported back to the grade book" %}.
{% trans "Scores were successfully reported back to the grade book." %}
{% trans "An error was encountered while reporting scores back to the grade book:" %}
{{last_report_process.response}}
{% trans "Report this error to your VLE's administrator." %}
{% trans "You can remark individual attempts on the attempts page." %}
{% trans "Download scores as CSV" %}
{% trans "No students have attempted this exam yet. Information about scores will appear here once a student attempts this exam." %}
{% endif %}


class: center, middle, inverse, title-slide # Lecture 11 ## Deforestation // Regression discontinuity ### Ivan Rudik ### AEM 6510 --- exclude: true ```r if (!require("pacman")) install.packages("pacman") pacman::p_load( tidyverse, xaringanExtra, rlang, patchwork, nycflights13, ggthemes ) options(htmltools.dir.version = FALSE) knitr::opts_hooks$set(fig.callout = function(options) { if (options$fig.callout) { options$echo <- FALSE } knitr::opts_chunk$set(echo = TRUE, fig.align="center") options }) ``` ``` ## Warning: 'xaringanExtra::style_panelset' is deprecated. ## Use 'style_panelset_tabs' instead. ## See help("Deprecated") ``` ``` ## Warning in style_panelset_tabs(...): The arguments to `syle_panelset()` changed in xaringanExtra 0.1.0. Please refer to the documentation to update your slides. ``` --- # Roadmap - Can we exploit situations when we know the mechanism for treatment assignment? - Can we exploit situations where some units are just above some threshold to get treatment, and others are just below the threshold? - Do deforestation policies work? --- class: inverse, center, middle name: hr2021 # Regression discontinuity

 --- # Regression discontinuity design Suppose we want to estimate the effect of air quality on property values -- We have a potentially large problem: -- there's quite a lot of things that affect housing values that may also be correlated with air quality -- - wealth, temperature, density, etc -- This makes `\(E[Y^0 | D = 1] - E[Y^0 | D = 0] \neq 0\)`, biasing any estimates because air quality will also pick up on these other factors that determine property values -- Here we will understand one way we can break this bias by exploiting .hi-red[discontinuities] --- # Regression discontinuity design The Clean Air Act mandates a set of National Ambient Air Quality Standards (NAAQS) -- The NAAQS require counties to keep ambient air concentrations of six pollutants below some (arbitrary-ish) threshold -- If a county goes above one of these thresholds, call them `\(c_0\)`, it is deemed to be in .hi-red[non-attainment] --- # Regression discontinuity design Non-attainment counties then face more stringent regulatory oversight and take up a host of actions aimed at reducing pollution back down to acceptable levels -- Non-attainment counties had .hi-red[much] greater pollution reductions during the 1970s and 1980s compared to attainment counties (Chay and Greenstone, 2005) --- # Regression discontinuity design The NAAQS generate a .hi-red[discontinuity:] -- counties just above the threshold in some year `\(T\)` face greater pressure to reduce pollution in subsequent years `\(T+1, T+2, \dots\)` compared to counties just below the threshold -- In the absence of this policy we might expect counties with `\(c_0 + \epsilon\)` levels of pollution to be similar to counties with `\(c_0 - \epsilon\)` in terms of .hi-blue[all other factors] (on average) - i.e. `\(E[Y^0 | D = 1] - E[Y^0 | D = 0] = 0\)` -- Thus any differences in property values is likely due to the NAAQS-induced decline in pollution in non-attainment counties --- # Regression discontinuity design This is the essence of the .hi-blue[regression discontinuity design (RDD)] -- Two counties with high vs low pollution are generally not comparable (e.g. high pollution areas have other disamenities, lower wealth) -- What if instead of comparing the two whole groups we did the following -- Compare two counties that have *virtually identical* levels of pollution, -- but -- where one is *just* above a threshold that forces it to significantly reduce pollution, and the other is *just* the below the threshold -- The subsequent difference in other outcomes we may consider .hi-red[as good as random] --- # Regression discontinuity design RDD is appropriate whenever a observational unit's assignment to treatment `\(D\)` .hi[jumps] in probability when some other variable `\(X\)`, called the running variable, is above some threshold `\(c_0\)` -- This makes sense right? -- Jumps are relatively unnatural, things typically change smoothly -- In RDD the jump is the chance of being put into treatment (in our example, under more regulatory scrutiny) --- # Regression discontinuity design With RDD we use our knowledge about how counties are selected into treatment (by going above the threshold `\(c_0\)`) in order to estimate the average treatment effect -- More precisely: we compare units just below to just above `\(c_0\)` to estimate something called a .hi-blue[local average treatment effect (LATE)] -- The .hi-blue[local] is because the estimate is only a valid ATE for units that have pollution levels near the threshold `\(c_0\)` -- Here's what we're doing in pictures --- # Regression discontinuity design: graphs ```r set.seed(12345) late <- 0 # local average treatment effect n_obs <- 1000 # number of observations rdd_df <- tibble( state = seq(1, n_obs)) %>% # control/untreated potential outcome mutate( X = rnorm(n(), 50, 25), # running variable D = X > 50, Y1 = 500 + late*D - 1.5*X + rnorm(n(), 0, 20) ) %>% filter(X > 0) %>% select( state, D, X, Y1 ) ``` --- # Regression discontinuity design: graphs .pull-left[ ![RDD is smooth without treatment](11-rdd_files/figure-html/rdd_base-1.png) ] .pull-right[ Suppose the pollution threshold is at 50 In the absence of the NAAQS, we expect a smooth/continuous transition in housing values above vs below the threshold Next, suppose we implement the NAAQS ] --- # Regression discontinuity design: graphs ```r set.seed(12345) late <- 40 # local average treatment effect (NOW 40) n_obs <- 1000 # number of observations rdd_df <- tibble( state = seq(1, n_obs)) %>% # control/untreated potential outcome mutate( X = rnorm(n(), 50, 25), # running variable D = X > 50, Y1 = 500 + late*D - 1.5*X + rnorm(n(), 0, 20) ) %>% filter(X > 0) %>% select( state, D, X, Y1 ) ``` --- # Regression discontinuity design: graphs .pull-left[ ![RDD LATE is around the threshold](11-rdd_files/figure-html/rdd_naaqs-1.png) ] .pull-right[ The policy induced greater pollution reductions in the non-attainment counties Housing prices shift up for those counties The vertical distance between the two groups at 50 is our .hi-blue[local average treatment effect] ] --- # Regression discontinuity design: the data We've seen what RDDs look like, what do we need to do one? -- RDD is about finding these .hi[jumps] in the probability of treatment as we move along some other variable `\(X\)` -- How do we find these jumps? -- For environmental topics they're often embedded in rules (e.g. the NAAQS), or across space (e.g. deforestation policy) --- # Regression discontinuity design: the data Good and plausible RDDs often involve `\(X\)`s having a 'hair trigger' that's not tightly related to the outcome - e.g. being 10 meters on either side of the Bolivia/Brazil border is pretty arbitrary in the grand scheme of things, but a massive discontinuity in deforestation policy -- We will need to be focused on the area right around this hair trigger threshold: that means we will need a lot of data near `\(c_0\)` in order to have precise estimates of the LATE --- # Regression discontinuity design: the types There are two classes of RDD: sharp and fuzzy -- .hi-blue[Sharp designs] are where the probability of treatment increases from 0 to 1 at the threshold `\(c_0\)` -- .hi-red[Fuzzy designs] are where the probability of treatment increases discontinuously at `\(c_0\)`, but not necessarily from 0 to 1 -- We will be focusing on sharp designs to keep it simple --- # Sharp RDD: set up A sharp RDD has treatment `\(D\)` being a deterministic function of the running variable `\(X\)` - e.g. deforestation policy is a deterministic function of distance from the Bolivia-Brazil border -- In a sharp RDD treatment is given by: `\begin{align} D_i = \begin{cases} 1 & X_i \geq c_0 \\ 0 & X_i < c_0 \end{cases} \end{align}` If we know `\(X_i\)` we know treatment with certainty --- # Sharp RDD: set up In potential outcomes terms we then have: `$$Y^0_i = \alpha + \beta X_i \\ Y^1_i = Y^0_i + \delta$$` -- Which gives us our regression is: `\begin{align} Y_i &= D_i Y^1_i + (1- D_i) Y^0_i \tag{Rubin model} \\ Y_i &= Y^0_i + (Y^1_i - Y^0_i)D_i \tag{Rearranged} \\ Y_i &= \alpha + \beta X_i + \delta D_i + \underbrace{\varepsilon_i}_{\text{Error}} \tag{Plug in above terms} \end{align}` -- What is the mathematical definition of `\(\delta\)`? --- # Sharp RDD: treatment effects `\(\delta\)` is the discontinuity in the .hi[conditional expectation function:] -- `\begin{align} \delta =& \lim_{X_i \rightarrow c_0} E[Y^1_i | X_i = c_0] - \lim_{c_0 \leftarrow X_i} E[Y^0_i | X_i = c_0] \\ =& \lim_{X_i \rightarrow c_0} E[Y_i | X_i = c_0] - \lim_{c_0 \leftarrow X_i} E[Y_i | X_i = c_0] \end{align}` -- The sharp RDD gives us an average causal effect of treatment .hi-blue[at the discontinuity,] which is why it is called a local average treatment effect (LATE): `$$\delta_{SRDD} = E[Y_i^1 - Y^0_i | X_i = c_0]$$` --- # Sharp RDD: treatment effects .pull-left[ ![](11-rdd_files/figure-html/unnamed-chunk-4-1.png)<!-- --> ] .pull-right[ Notice that .hi[extrapolation] plays a key role: there is no `\(X\)` where we have some units with `\(D_i = 1\)` and others with `\(D_i = 0\)` We are extrapolating (locally around `\(c_0\)`) using the dashed lines to estimate the difference in the two means ] --- # Sharp RDD: identifying assumption The identifying assumption for RDD is called the .hi-blue[continuity assumption:] > `\(E[Y^0_i|X = c_0]\)` and `\(E[Y^1_i|X = c_0]\)` are continuous (smooth) in `\(X\)` at `\(c_0\)` It means that the expected potential outcomes should remain continuous at the threshold in the absence of treatment: they would not have jumped -- If this is true, then all other determinants of `\(Y\)` are thus continuously related to `\(X\)` and the jump is completely due to treatment --- class: inverse, center, middle name: hr2021 # The Brazilian Amazon’s Double Reversal of Fortune

 --- # What is the paper about? What is Burgess et al. (2019) (.hi[BCO]) about? -- BCO aims to estimate the .hi-red[causal] effect of deforestation regulation in Brazil -- Why is this important? -- 1. The Amazon rainforest is incredibly important -- 2. The Amazon is largely undeveloped, unclear if deforestation regulation can be adequately enforced to matter -- 3. Understanding whether the regulation works is important for future policy --- # How does the paper do it? BCO estimate the causal effect of Brazil's deforestation policy by exploiting a spatial discontinuity -- BCO does this using a RDD variant called .hi-blue[spatial RDD] -- They compare deforestation outcomes in Brazil, to those in other countries, close to the country border --- # How does the paper do it?

 Bolivia is on the left, Brazil is on the right -- Darker green is more forested -- Red is protected, blue is private -- Sharp discontinuities in forest cover are very clear all along the border (black) --- # How does the paper do it? In the spatial RDD the running variable `\(X\)` is distance from the border - Negative values for other countries, positive values for Brazil -- Their model is similar to what we just went over with sharp RDD: `$$Y_i = \delta \text{Brazil}_i + f(\text{distance to border}_i) + \text{controls} + \varepsilon_i$$` Here: - `\(\text{Brazil}_i \equiv D_i\)` - `\(f(\text{distance to border}_i) \equiv X_i\)` --- # How does the paper do it? The paper also includes a set of controls for things that may be different/discontinuous across the border (e.g. national infrastructure, elevation, etc) -- BCO's key assumption is that other factors that affect deforestation change smoothly across the border -- This is likely reasonable: the borders were arbitrarily set in 1750 when the area was virtually unexplored: where the border is .hi-blue[locally] is effectively random -- They also find no discontinuities in other things that may be important for deforestation: roads, slope, distance to cities, etc --- # What they get The forest data are very, very large (120 meter pixels!) so we won't be doing this hands on --- # What they get

 0 is the border, to the right is Brazil, to the left is other countries, the year is 2000 -- Other countries have greater forest cover than Brazil, but with a slight decline as you move to the Brazil border -- Brazil has discontinuously lower forest cover near the border --- # What they get

 BCO also runs the RDD year-by-year so we can see how the LATE changes over time -- The effect of being in Brazil goes to zero for about 2006-2014 -- This is about when Brazil implemented tougher national deforestation policies: *Action Plan for the Prevention and Control of Deforestation in the Legal Amazon, Law on Public Forest Management, etc* --- # What they get: deforestation LATE by year

 The effect of the tougher policies seems to have gone away after 2014 -- Why? -- Economic crises decreased enforcement of environmental regulations, and lead to weakening of the regulations


--- layout: default title: Contact us ---
We'd love to hear from you. The easiest way for us is via email, but we can also respond via Twitter.
If you'd like to chat with us in real-time, please send a calendar invitation to<EMAIL_ADDRESS>and we'll see what we can do (as G-chat's now been phased out).
You can call us on 0845 835 8553 (UK only)
To meet us, face-to-face please make an appointment: we're usually based off the Strand, in London, on Adam Street (WC2N 6LE).
Our registered address, in the unlikely case that you need it is:
Rewired State Ltd.Rewired Imagination is a trading name/operation wholly owned/operated by Rewired State Ltd.
Rewired State Ltd. Incorporated in England and Wales with Company № 07149780. Registered address: Rewired State Ltd, Ordman House London, Unit 1, 26 Cleveland Road, London, E18 2AN. VAT №: GB 990 0154 32. Registered with the Information Commissioner's Office with Registration Reference: ZA011866.


DigiCert Services is the API that gives you flexibility to simplify certificate management in a way that works best for your organization.


FROM RITA GUEI
Abidjan cote D`Ivoire
West Africa.
Dearest One,
I am the first duaghter of an ex military/ex president been an opposition party to the present Government of COTE D`IVOIRE. On the 19th sept 2002 my father/mother including every members of our family was murdered by the unknown REBELS during the time they attack our house by shooting and looting, even this is one of the things that contributed to the present crisis in our country today.
God so kind I was not in town when the incident occurred, the plans of the REBELS is to kill every members of our family so that no one will rise up to revenge as time goes on. I am in our country without any one knowing although I am on hiding so that the unknown REBELS will not get to me and kill me like they killed all the members of our family. Why I still stay back in our country is to transfer the $18.5mUSD which my late
father deposited in the custody.
he deposited the fund as a family treasure containing AFRICAN ART WORK FOR EXPORT for security reasons, as security company does not operate as bank where some one can deposit his/her money openly.
Before the death of my father he gave me the covering documents of the fund deposited in the security company, as I am his first duaghter and he so much loved me that was why he made me the beneficiary of the two iron trunk boxes containing the $18.5mUSD. Right now I wish to transfer this fund to you so that you will assist me to invest the money into any viable sector in your country, also you will help me to join you in your country for me to start up a new life with you there immediately the fund gets to you. since I am no longer safe as far as Africa is concern at the moment, I wanted to transfer the fund before leaving the country because this fund is my last hope and the only hope I have now.
Before I
even pick you to assist me I have prayed and slept over it asking God to provide for me a Godly minded person that will assist me in this transaction. I will give you more details of the transaction in my next mail.
Awaiting to hear from you,
Thanks and God bless you.
Rita Guei.
Nouveau : téléphonez moins cher avec Yahoo! Messenger. Appelez le monde entier à partir de 0,012 €/minute !
Téléchargez la version beta.
Nouveau : téléphonez moins cher avec Yahoo! Messenger. Appelez le monde entier à partir de 0,012 €/minute !
Téléchargez la version beta.


|
FlatBuffers
|
Comparing against other serialization solutions, running on Windows 7 64bit. We use the LITE runtime for Protocol Buffers (less code / lower overhead), and Rapid JSON, one of the fastest C++ JSON parsers around.
We compare against Flatbuffers with the binary wire format (as intended), and also with JSON as the wire format with the optional JSON parser (which, using a schema, parses JSON into a binary buffer that can then be accessed as before).
The benchmark object is a set of about 10 objects containing an array, 4 strings, and a large variety of int/float scalar values of all sizes, meant to be representative of game data, e.g. a scene format.
| FlatBuffers (binary) | Protocol Buffers LITE | Rapid JSON | FlatBuffers (JSON) | |
|---|---|---|---|---|
| Decode + Traverse + Dealloc (1 million times, seconds) | 0.08 | 302 | 583 | 105 |
| Decode / Traverse / Dealloc (breakdown) | 0 / 0.08 / 0 | 220 / 0.15 / 81 | 294 / 0.9 / 287 | 70 / 0.08 / 35 |
| Encode (1 million times, seconds) | 3.2 | 185 | 650 | 169 |
| Wire format size (normal / zlib, bytes) | 344 / 220 | 228 / 174 | 1475 / 322 | 1029 / 298 |
| Memory needed to store decoded wire (bytes / blocks) | 0 / 0 | 760 / 20 | 65689 / 40 | 328 / 1 |
| Transient memory allocated during decode (KB) | 0 | 1 | 131 | 4 |
| Generated source code size (KB) | 4 | 61 | 0 | 4 |
| Field access in handwritten traversal code | accessors | accessors | manual error checking | accessors |
| Library source code (KB) | 15 | some subset of 3800 | 87 | 43 |


Sword Art Online II
A year has passed since the SAO incident. Kirito receives a strange request from Seijiro Kikuoka of the Ministry of Internal Affairs and Communications, Virtual Division. He has been researching a strange phenomenon, Death Gun, that suddenly occurred in the VRMMO Gun Gale Online (GGO).  Kirito is unable to ...


Jeremy Zhu
Web Developer in Training.
Jeremy Zhu
Web Developer // Boba Connoisseur // Photographer
Hi, my name is Jeremy. I am a current student of the UT Bootcamp. Currently am a Web Developer in training. Fun facts, I speak 4 languages, love photography, and play too much games.


Conditioner = require "./index"
_ = require "underscore"
Conditioner = require "./index"
_ = require "underscore"
determine replies to an array of coffee (or possibly not) orders
replyToOrders = (orders) ->
order conditions for validity
validity = new Conditioner()
.add starts: 'order|get'
.add contains: 'coffee(s)?', 'coffeePlural'
.add excludes: 'not'
order details
deets = new Conditioner()
.add contains: 'me', 'forSelf'
.add range: '1-999', 'qty'
.add after: 'for', 'for'
.add ends: 'please', 'polite'
_.map orders, (order) ->
detail = deets.capture order # capture details
valid = validity.compare order # test validity
get parts
coffeePlural = validity.matches.coffeePlural?[0] # coffee, coffees or undefined
qty = detail.qty ? '1'
who = if detail.forSelf then "you" else detail.for ? "I dunno?"
polite = if detail.polite then yes else no
compose
switch
when valid and polite
"#{ qty } #{ coffeePlural } for #{ who }. Have a nice day :)"
when valid
"#{ qty } #{ coffeePlural } for #{ who }"
when not valid and polite
"Sorry, no."
else
"No coffee for you."
coffee orders, input received
orders = [
'Order me a coffee please'
'Order 2 coffees for Otis'
'Get me 100 coffees'
'Order Borat 10 coffees please... NOT!'
'Order me a horse, please'
'I love lamp'
]
console.log replyToOrders orders
##
Outputs:
[ '1 coffee for you. Have a nice day :)',
'2 coffees for Otis',
'100 coffees for you',
'No coffee for you.',
'Sorry, no.',
'No coffee for you.' ]
##


Arithmetic constraints
[Testing finite domain integers]
Classes | |
| class | Test::Int::Arithmetic::MultXYZ |
| Test for multiplication constraint More... | |
| class | Test::Int::Arithmetic::MultXXY |
| Test for multiplication constraint with shared variables More... | |
| class | Test::Int::Arithmetic::MultXYX |
| Test for multiplication constraint with shared variables More... | |
| class | Test::Int::Arithmetic::MultXYY |
| Test for multiplication constraint with shared variables More... | |
| class | Test::Int::Arithmetic::MultXXX |
| Test for multiplication constraint with shared variables More... | |
| class | Test::Int::Arithmetic::SqrXY |
| Test for squaring constraint More... | |
| class | Test::Int::Arithmetic::SqrXX |
| Test for squaring constraint with shared variables More... | |
| class | Test::Int::Arithmetic::SqrtXY |
| Test for square root constraint More... | |
| class | Test::Int::Arithmetic::SqrtXX |
| Test for square root constraint with shared variables More... | |
| class | Test::Int::Arithmetic::PowXY |
| Test for power constraint More... | |
| class | Test::Int::Arithmetic::PowXX |
| Test for power constraint with shared variables More... | |
| class | Test::Int::Arithmetic::NrootXY |
| Test for nroot constraint More... | |
| class | Test::Int::Arithmetic::NrootXX |
| Test for nroot constraint with shared variables More... | |
| class | Test::Int::Arithmetic::DivMod |
| Test for division/modulo constraint More... | |
| class | Test::Int::Arithmetic::Div |
| Test for division constraint More... | |
| class | Test::Int::Arithmetic::Mod |
| Test for modulo constraint More... | |
| class | Test::Int::Arithmetic::AbsXY |
| Test for absolute value constraint More... | |
| class | Test::Int::Arithmetic::AbsXX |
| Test for absolute value constraint with shared variables More... | |
| class | Test::Int::Arithmetic::MinXYZ |
| Test for binary minimum constraint More... | |
| class | Test::Int::Arithmetic::MinXXY |
| Test for binary minimum constraint with shared variables More... | |
| class | Test::Int::Arithmetic::MinXYX |
| Test for binary minimum constraint with shared variables More... | |
| class | Test::Int::Arithmetic::MinXYY |
| Test for binary minimum constraint with shared variables More... | |
| class | Test::Int::Arithmetic::MinXXX |
| Test for binary minimum constraint with shared variables More... | |
| class | Test::Int::Arithmetic::MaxXYZ |
| Test for binary maximum constraint More... | |
| class | Test::Int::Arithmetic::MaxXXY |
| Test for binary maximum constraint with shared variables More... | |
| class | Test::Int::Arithmetic::MaxXYX |
| Test for binary maximum constraint with shared variables More... | |
| class | Test::Int::Arithmetic::MaxXYY |
| Test for binary maximum constraint with shared variables More... | |
| class | Test::Int::Arithmetic::MaxXXX |
| Test for binary maximum constraint with shared variables More... | |
| class | Test::Int::Arithmetic::MinNary |
| Test for n-ary minimmum constraint More... | |
| class | Test::Int::Arithmetic::MinNaryShared |
| Test for n-ary minimmum constraint with shared variables More... | |
| class | Test::Int::Arithmetic::MaxNary |
| Test for n-ary maximum constraint More... | |
| class | Test::Int::Arithmetic::MaxNaryShared |
| Test for n-ary maximum constraint with shared variables More... | |
| class | Test::Int::Arithmetic::ArgMax |
| Test for argument maximum constraint More... | |
| class | Test::Int::Arithmetic::ArgMaxShared |
| Test for argument maximum constraint with shared variables More... | |
| class | Test::Int::Arithmetic::ArgMin |
| Test for argument minimum constraint More... | |
| class | Test::Int::Arithmetic::ArgMinShared |
| Test for argument minimum constraint with shared variables More... | |
| class | Test::Int::Arithmetic::Create |
| Help class to create and register tests. More... | |
Functions | |
| bool | Test::Int::Arithmetic::powgr (int n, long long int r, int x) |
| int | Test::Int::Arithmetic::fnroot (int n, int x) |
| bool | Test::Int::Arithmetic::powle (int n, long long int r, int x) |
| int | Test::Int::Arithmetic::cnroot (int n, int x) |
Variables | |
| Create | Test::Int::Arithmetic::c |
Function Documentation
| bool Test::Int::Arithmetic::powgr | ( | int | n, | |
| long long int | r, | |||
| int | x | |||
| ) |
Definition at line 285 of file arithmetic.cpp.
| int Test::Int::Arithmetic::fnroot | ( | int | n, | |
| int | x | |||
| ) |
Definition at line 297 of file arithmetic.cpp.
| bool Test::Int::Arithmetic::powle | ( | int | n, | |
| long long int | r, | |||
| int | x | |||
| ) |
Definition at line 312 of file arithmetic.cpp.
| int Test::Int::Arithmetic::cnroot | ( | int | n, | |
| int | x | |||
| ) |
Definition at line 325 of file arithmetic.cpp.
Variable Documentation
| Create Test::Int::Arithmetic::c |
Definition at line 1076 of file arithmetic.cpp.


#include <algorithm>
#include <iostream>
#include <vector>
#include <thread>
#include <future>
#include "Z2.hpp"
#include "SO6.hpp"
|
| SO6 | tMatrix (int i, int j) |
| |
| bool | containedIn (std::vector< SO6 > &v, SO6 &entry) |
| |
| std::vector< std::vector< SO6 > > | mergedVect (std::vector< std::vector< SO6 >> &a, std::vector< std::vector< SO6 >> &b) |
| |
| std::vector< std::vector< SO6 > > | genProds (std::vector< SO6 > &oneLDE, int tCount, std::vector< SO6 > &tmats) |
| |
| std::vector< std::vector< SO6 > > | genAllProds (std::vector< std::vector< SO6 >> &TminusOne, int tcount, std::vector< SO6 > &tmats) |
| |
| std::vector< SO6 > | genPerms (std::vector< SO6 > &oneLDE, int LDE, std::vector< std::vector< std::vector< SO6 >>> &lowerTs) |
| |
| std::vector< std::vector< SO6 > > | genAllPerms (std::vector< std::vector< SO6 >> &unReduced, std::vector< std::vector< std::vector< SO6 >>> &lowerTs) |
| |
|
int | main () |
| |
T Operator Product Generation Main File
- Author
- Connor Mooney
-
Michael Jarret
-
Andrew Glaudell
-
Jacob Weston
-
Mingzhen Tian
- Version
- 5/20/21
◆ containedIn()
| bool containedIn |
( |
std::vector< SO6 > & |
v, |
|
|
SO6 & |
entry |
|
) |
| |
Returns whether or not an SO6 is contained in a vector of SO6
- Parameters
-
| v | the vector of SO6 to be checked for v |
| entry | the SO6 to be compared to elements of v |
- Returns
- whether or not v is contained in entry
◆ genAllPerms()
| std::vector<std::vector<SO6> > genAllPerms |
( |
std::vector< std::vector< SO6 >> & |
unReduced, |
|
|
std::vector< std::vector< std::vector< SO6 >>> & |
lowerTs |
|
) |
| |
Takes a vector of vectors of SO6, all with the same T-Count, broken out by LDE, and checks for equivalence to lower T-Count operators
- Parameters
-
| unReduced | the vector of vectors of SO6, sorted by LDE, to be checked |
| lowerTs | the vector the distributions of all lower T-count operators |
- Returns
- a vector of vectors of SO6, broken out by LDE, of the unique elements of unReduced, up to signed column permutation
◆ genAllProds()
| std::vector<std::vector<SO6> > genAllProds |
( |
std::vector< std::vector< SO6 >> & |
TminusOne, |
|
|
int |
tcount, |
|
|
std::vector< SO6 > & |
tmats |
|
) |
| |
Takes a vector of vectors of SO6, all with the same T-Count, broken out by LDE, and multiplies each element by those of another vector of SO6 and returns them sorted by LDE as well
- Parameters
-
| TminusOne | the vector of vectors of SO6, sorted by LDE, to be multiplied |
| tcount | the T-Count of TminusOne |
| tmats | the vector of SO6 whose elements will be multiplying those of TminusOne |
- Returns
- the product of all elements of TminusOne and tmats, sorted by LDE
◆ genPerms()
| std::vector<SO6> genPerms |
( |
std::vector< SO6 > & |
oneLDE, |
|
|
int |
LDE, |
|
|
std::vector< std::vector< std::vector< SO6 >>> & |
lowerTs |
|
) |
| |
Takes a vector of SO6 all with the same LDE, and compares to same LDE of lower T counts to check for permutation
- Parameters
-
| oneLDE | A vector of SO6 all with the same LDE |
| LDE | the LDE of oneLDE |
| lowerTs | the vector the distributions of all lower T-count operators |
- Returns
- a vector of all elements of oneLDE not equivalent up to signed column-permutation, to any elements of lowerTs
◆ genProds()
| std::vector<std::vector<SO6> > genProds |
( |
std::vector< SO6 > & |
oneLDE, |
|
|
int |
tCount, |
|
|
std::vector< SO6 > & |
tmats |
|
) |
| |
multiplies every entry of a vector of SO6 with every entry of another vector, and returns it sorted by LDE
- Parameters
-
| oneLDE | vector of SO6 |
| tCount | the T-count that the vector came from (used to determine the number of LDEs of the returned vector) |
| tmats | another vector of SO6 to multiply, we will always pass it the vector of the 15 T-Count 1 matrices though |
- Returns
- a vector of vectors of SO6, containing the products of elements of tCounts and oneLDE, sorted by LDE
◆ mergedVect()
| std::vector<std::vector<SO6> > mergedVect |
( |
std::vector< std::vector< SO6 >> & |
a, |
|
|
std::vector< std::vector< SO6 >> & |
b |
|
) |
| |
Returns the itemwise union of two vectors of vectors of SO6
- Parameters
-
| a | a vector of vectors of SO6 |
| a | another vector of vectors of SO6 |
- Returns
- m, where m[i] = a[i] union b[i]
◆ tMatrix()
| SO6 tMatrix |
( |
int |
i, |
|
|
int |
j |
|
) |
| |
Returns the SO6 object corresponding to T[i+1, j+1]
- Parameters
-
| i | the first index to determine the T matrix |
| j | the second index to determine the T matrix |
- Returns
- T[i+1,j+1]


Plasma¶
Warning
This information (particularly code examples) is not up-to-date.
This module calculates the ionization balance and level populations in BasePlasma, give a abundance fraction, temperature
and density. After calculating the state of the plasma, these classes are able to calculate \(\tau_\textrm{sobolev}\)
for the supernova radiative transfer. The simplest BasePlasma (BasePlasma
) only calculates the atom number densities, but serves
as a base for all BasePlasma classes. The next more complex class is LTEPlasma which will calculate the aforementioned quantities in
Local Thermal Equilibrium conditions (LTE). The NebularPlasma
-class inherits from LTEPlasma and uses a more complex
description of the BasePlasma (for details see nebular_plasma).
Note
In this documentation we use the indices \(i, j, k\) to mean atomic number, ion number and level number respectively.
All plasma calculations follow the same basic procedure in calculating the plasma state.
This is always accomplished with the function update_radiationfield
. This block diagram shows the basic procedure
Base Plasma¶
BasePlasma serves as the base class for all plasmas and can just calculate the atom number densities for a given input of abundance fraction.
In the next step the line and level tables are purged of entries that are not represented in the abundance fractions are saved in BasePlasma.levels and BasePlasma.lines. Finally, the function BasePlasma.update_t_rad is called at the end of initialization to update the plasma conditions to a new \(T_\textrm{radiation field}\) (with the give t_rad). This function is the same in the other plasma classes and does the main part of the calculation. In the case of BasePlasma this is only setting BasePlasma.beta_rad to \(\frac{1}{k_\textrm{B}T_\textrm{rad}}\).
Here’s an example how to instantiate a simple base plasma:
>>> from tardis import atomic, plasma
>>> atom_data = atomic.AtomData.from_hdf5()
>>> my_plasma = plasma.BasePlasma({'Fe':0.5, 'Ni':0.5}, 10000, 1e-13, atom_data)
>>> print my_plasma.abundances
atomic_number abundance_fraction number_density
------------- ------------------ --------------
28 0.5 513016973.936
26 0.5 539183641.472
Plasma Types¶
Sobolev optical depth¶
This function calculates the Sobolev optical depth \(\tau_\textrm{Sobolev}\)


Preparation time
over 2 hours
Cooking time
30 mins to 1 hour
Serves
Serves 6
Dietary
This classic French apple tart is given an English garden feel by adding lavender. All-butter puff pastry topped with lavender-scented caramelised apples.
To make the pastry, rub the 65g/2¼oz butter into the flour and salt with your fingertips until it resembles breadcrumbs. In a separate bowl lightly mix the vinegar with 150g/5½oz water then add this to the dry mix and combine to make a dough. Transfer to the freezer for 10 minutes.
While the dough is chilling in the freezer, flatten the remaining 250g/9oz butter by placing it between two sheets of greaseproof paper and using a rolling pin to squash it into a square shape less than 1cm/½in thick.
Roll out the chilled pastry dough to form a rectangle twice the size of the flattened butter square. Fold the pastry over the butter, then turn it 90 degrees and roll it out until it has doubled in length. Fold both ends into the middle, then fold once more (to ‘close the book’). Transfer to the fridge for 20 minutes.
For the topping, mix the lavender with the caster sugar to infuse. Take four of the apples, slice them into wedges and set aside. Cut the remaining apples into halves and place them on a cooling rack. Transfer to the fridge to oxidise slightly.
For the pastry, repeat the rolling and folding process another three times and return to the fridge.
Preheat the oven to 200C/400F/Gas 6.
For the topping, add the lavender sugar, 20g/¾oz water and lemon juice to a heavy oven-proof frying pan and heat until the sugar has dissolved and a light caramel has formed. Remove from heat, add the butter and salt and swirl the pan occasionally until combined (don’t stir as this can make the caramel crystalise).
Place the halved apples in the centre of the pan, cut side down. Arrange the apples wedges around the halves and return the pan to a low heat for five minutes, then set aside to cool slightly.
For the pastry, repeat the rolling and folding process one more time, then carefully roll it out to fit the pan. Place the pastry on top of the pan, trim any excess - leaving a small overhang to tuck down the inside of the pan.
Bake for 30 minutes, or until the pastry is golden and crisp. Remove the tarte tatin from the oven and turn out onto a plate (take care with this as the caramel will still be very hot) and allow to cool for five minutes before serving with a spoonful of clotted cream.


Numbers 25:1
And Israel abode in Shittim, and the people began to commit whoredom with the daughters of Moab.


Welcome to Team Instinct!
If you chose the wrong page, click on the following links to go to the correct page.
We may be few in numbers, but we are Mighty
This electrifying Pokemon was also known as Thunder in Japan.
There is no shelter from the Storm
- The Key to Success is Following Your Own Instincts
- Believe in Trust & Intuition
- Let Your Unique Shine Through


Before year 2012, GMS has developed several product which has received excellent feedback from Customer.
Below are the list of Products:-
CQMS300i QMS300i QMS250i QMS210i
QMS150i QMS50i QMS20i QMS10i
DG30 DG20 DG10
At Year 2012, GMS continue to develop well known product to Our Customer.
Below are the list of products:-
CQMS600i QMS500i QMS600i
In the early of 2016, GMS has upgraded the system and develop a new product which has included the updated features.
Below are the list of the products:-
CQMS600i QMS700i
GMS does not slow down the progress to develop product, We continue to develop several excellent product in the Middle and End of year 2016
Below are the list of the products:-
Middle of 2016 : QMS400i
End of 2016 : QMS60i QMS30i DG50
At year 2017, GMS has develop a whole new System which has enlarge the opportunity to make Our Company to become the leading Company under this field
Below is the product:-
Cloud/EnterpriseQMS


WITNESS LIST
Transportation Committee
April 18, 2018 - 9:00 AM
Toll Authority Responsiveness and Transparency
For:
Sepulveda Jr., Pete (Cameron County Regional Mobility Authority)
On:
Ballesteros, Arturo (North Texas Tollway Authority)
Bass, James (TxDOT)
Green, Renee (Bexar County Alamo RMA)
Hall, Terri (Self; Texas TURF and Texans for Toll-free Highways)
Heiligenstein, Mike (Central texas regional mobilty authority)
Key, Peter (Harris County Toll Road Authority)
Miller, Chris (Northeast Texas Regional Mobility)
Ragland, Brian (TxDOT)
Stone, Mike (FBCTRA /FBGPTRA)
White, David (Texans for Traffic Relief)
Registering, but not testifying:
On:
Nelson, Rick (TxDOT)
Williams, Marc (TxDOT)
Transportation Financing
For:
Jenkins, Bobby (Self; Austin Chamber of Commerce)
Kleinman, Lee (City of Dallas)
McGough, Adam (Dallas City Council)
On:
Ballesteros, Arturo (North Texas Tollway Authority)
Bass, James (TxDOT)
Bugg, Bruce (Texas Transportation Commission)
Conley, Will (Campo)
Glover, Brianne (Texas A&M Transportation Institute)
Green, Renee (Bexar County Alamo RMA)
Heiligenstein, Mike (Central texas regional mobilty authority)
Key, Peter (Harris County Toll Road Authority)
Latsha, Rob (Texas Bond Review Board)
Ragland, Brian (TxDOT)
Williams, Marc (TxDOT)
1


Catherine Mazza, Greg Rozmarynowycz, Brianna Jones, and Tyler Russell are RIT students who wish to solve common problems found on campuses around the country.
Posts pertaining to repairs for computers, phones, bikes. ANYTHING.
Finding unique and creative merchandise made by students.
Requests for services that are not found in other categories.

Need help with course work? Find the tutor that fits your needs.
Nails. Makeup. Hair. All Cosmetics. Everything you need to look awesome.


--- layout: post authors: ["Daniel Chen"] title: "Cookie Cutter" date: 2015-02-10 time: "06:00:00" tags: ["Reproducibility", "Tools"] ---
I was first introduced to William Stafford Noble's paper "A Quick Guide to Organizing Computational Biology Projects" when Ivan Gonzalez and I taught Harvard last November. Noble describes how scientists in Computational Biology should set up their project folders so code, results, outputs, figures, and papers are all in easily understandable locations. He also writes about how one should run experiments (using driver scripts) to make workflows reproducible, readable, and understandable to others (and your future self).
I recently reorganized a project I was working on to follow Nobe's folder structure, and when I started a new computational project, I realized I would have to create the same folder structure again. Since, we're in the business of not repeating ourselves, I created a short Bash script that implements the basic folder structure outlined by Noble. When I brought up the project to our discussion board, Pat Schloss chimed in with a similar project based on the same motivational paper, and my project even got a pull request!
"Cookie cutter" projects are quite common — essentially, they are pre-built templates for project that follow some kind of convention for folder structures and basic boilerplate.
For Software Carpentry, it serves as a way for us to teach our attendees some best practices while showing them the importance of reproducibility and scripts. It also allows a low barrier of entry to actually set up a project folder structure, since re-organizing folders when a project is fully developed will most likely not happen.
If you use cookie cutter project templates of some kind, we'd like to hear about them: please add pointers to this GitHub issue or mail us directly.


The idea of conducting an inter-college astro-meet was the brain-child of Akshita. When she applied for the position of coordinator of STAC, IIT Mandi, one of the major plans in her propaganda was conducting an inter-college astro-meet here in IIT Mandi, something that was never thought of or discussed earlier. It remained dormant for a long time until one day, Shreyas, the former coordinator discussed with Akshita to work on her vision. This time, they decided to realise this dream and presented the idea before the core team and Akash Dakoor and Ananya Shukla, the then coordinators of the club. It was met with much excitement and enthusiasm from the members and that was how the process of conducting the ever Astro-Meet of the North India began. The term 'AstraX' was coined by Shreyas.
The preparations of the fest involved approaching people who have made a mark in the field of theoretical and computational astronomy, astrophysics and space technology and inviting them to deliver keynote lectures that would further arouse the interest of students in this field and organising a variety of competitive events ranging from hackathon to Messier Hunt that would further add to the enthusiasm of the participants. This was followed by extensive publicity among different colleges of the country in order to bring people from different streams to one platform, uniting them by their interest in astronomy. The AstraX team comprised students from different years who worked together to make this dream come true.


{% extends "dewater_py/base.html" %} {% block app_content %}
Congratulations on creating a new Tethys app!


Calculate the relative team strength based on the results you entered before.
Enjoy this bunny while you're waiting.
Refresh


Honzi
/
Guides
/
World of Warcraft
/
Professions
/Mining
Mining is a good second profession to get to help you train and gather supplies for:
Blacksmithing
Engineering
Mining Recipes
Level
Input
Notes
[Copper Bar]
1
1
[Copper Ore]
Automatically learned when you learn the mining profession.


Google's Driverless Car
The google self driving cars, one of the products of google x among others such as electric cars and others. The software powering these is called google chauffeur. A number of cars have adopted this among which Toyota Prius, Audi TT, and Lexus RX450h are few. The range finder mounted on the top of the vehicle is a Velodyne 64-beam laser. This laser allows the vehicle to generate a detailed 3D map of its environment. The car then takes these generated maps and combines them with high-resolution maps of the world, producing different types of data models that allow it to drive itself. The car hasn't been as reliable when it comes to road accidents though, being involved in 14 minor traffic accidents on public roads as of July 2015, but Google maintains in all cases that the vehicle was not at fault as they were either being manually driven or the driver of another vehicle was at fault.
The Google Glass
Well this piece is quite a model to watch out for. The Google Glass displays information in a smartphone-like hands-free format. With an optical head-mounted display we can communicate with the Internet via natural language voice commands or by a touchpad provided at the side. The touchpad allows users to control the device by swiping through a timeline-like interface displayed on the screen. Sliding backward shows current events, such as weather, and sliding forward shows past events, such as phone calls, photos, circle updates, etc. Add to it, the Google Glass also has the ability to take photos and record 720p HD video.
The Google Contact Lens
Google's approach to this product is really commendable. The Google contact lens has a wireless chip and can also measure blood sugar levels. A tiny pinhole in the lens allows for tear fluid to seep into the sensor to measure blood sugar levels. The electronics lie outside both the pupil and the iris so there is no damage to the eye. There is a wireless antenna inside of the contact which acts as a controller to communicate information to the wireless device. The best thing about it is that it's even thinner than a human's hair and is responsible for gathering, reading and analyzing data. There have been propositions of adding a small LED light that will warn the wearer by lighting up when the glucose levels have crossed above or below a certain level, but limitations such as the toxic metal arsenic present in the LED's have barred such an addition to the Google lens.
Project Loon
Project loon is Google's way of solving the problem of providing Internet in far off rural places. It is a high altitude balloon network operating in the stratosphere, at altitudes between 18km and 25km. This particular layer is advantageous because of its relatively low wind speeds and minimal turbulence, according to Google. Google also claims that it can control the latitudinal and longitudinal position of the high-altitude balloons by adjusting only the balloon's altitude. By adjusting the volume and density of the gas in the balloon, the balloon's variable buoyancy system is able to control the balloon's altitude. The technology designed in the project could allow countries to avoid using expensive fiber cable that would have to be installed underground to allow users to connect to the Internet. Google feels this will greatly increase Internet usage in developing countries in regions such as Africa and Southeast Asia that can't afford to lay underground fiber cable.
Google Street View
Google Street View is a technology featured in Google Maps and Google Earth that provides panoramic views from positions along many streets in the world. It was launched in 2007 in several cities in the United States, and has since expanded to include cities and rural areas worldwide. Streets with Street View imagery available are shown as blue lines on Google Maps. Google Street View displays panoramas of stitched images. Most photography is done by car, but some is done by trekker, tricycle, walking, boat, snowmobile, camel, and underwater apparatus.


#Movement.js
Movement.js is library for recognition of basic gestures using JavaScript and HTML5. Demo videos can be found here and here.
#How to use it?
You can initialize it by:
Movement.init(callbacks);
The callbacks
object can contain the following callbacks:
movementChanged
- callback which will be invoked when the user gesture is changed.positionChanged
- callback which will be invoked when the user change his position in the visible area.
Both callbacks accept a single argument the new callback/movement.
###List of movements
This is list of all gestures which Movement.js can currently recognize:
STAND
LEFT_ARM_UP
RIGHT_ARM_UP
ARMS_UP
SQUAT_LEFT_ARM_UP
SQUAT_RIGHT_ARM_UP
LEFT_LEG_UP
SQUAT
EMPTY
RIGHT_LEG_UP
All movements are located in the namespace Movement.movements
.
###List of positions
This is list of all positions which Movement.js supports currently:
LEFT
RIGHT
MIDDLE
EMPTY
All positions are located in the namespace Movement.positions
.
###Example
Movement.init({
positionChanged: function (pos) {
if (pos === Movement.positions.LEFT) {
console.log('You\'re in the left part of the visible zone');
}
},
movementChanged: function (mov) {
if (mov === Movement.movements.RIGHT_LEG_UP) {
console.log('You\'re kicking?');
}
}
});
#License
This software is distributed under the terms of the MIT license.


HOVER ON
Nature & Beauty
HOVER ON
Food & Drink
HOVER ON
Street Photography
HOVER ON
Health & Wellness


MOST USEFUL WEBSITES..
1.Educational
2.Entertainment
3.News
4.Social
FOR NEWS-Check These Sites
AajTak
ABCNews
BBC News
CNN
Fox News
Google News
Huffington Post
IBNLive
NBC News
ThinkDigit
Yahoo! News
INDIA TV


Main - Service Launcher¶
This module provides functionality to the raspi-rtl shell script.
Note
This script should only be run from the main raspi-rtl shell script.
-
rtl.main.
COLOURS
¶ class of terminal colours.
- Type
object
-
rtl.main.
NODES
¶ A list of node objects containing a class reference and a count.
- Type
list
- Todo
Find a better way to handle args in the
run
function (less cyclomatic complexity).
-
class
rtl.main.
Launcher
¶ Launcher is class for handling all the setup logic for running an RTL cluster.
-
nodes
¶ A list of node objects defined in the beginning of this module/
- Type
list
-
conf
¶ The configuration module.
- Type
module
-
parser
¶ ArgumentParser class object.
- Type
class
-
args
¶ Namespace class object:
meta (bool): True to print meta, else False to run script.
no_server (bool): Default to False, pass True for tests.
- Type
class
-
functions
¶ A dict of task modules.
- Type
dict
-
__init__
()¶ Initializer for the
Launcher
class.
-
_keep_alive
()¶ serve function for executing the main process loop
Warning
This is a private member and should never be called directly.
- Raises
SystemExit – natural termination point for program if testing flag
no_server
is True.
-
_launch
(service_class, count)¶ Call startNode on each service and check for exceptions.
Warning
This is a private member and should never be called directly.
- Parameters
service_class (ClassType) – The name of a valude service class.
count (int) – the number of service_class instances to start.
- Returns
True if all services launched successfully, False otherwise.
- Return type
bool
-
_print_meta
()¶ Print the loaded tasks to the console.
Warning
This is a private member and should never be called directly.
- Raises
SystemExit – natural termination point for program.
-
_start_node
(service_class, count)¶ Start a subprocess for each micro-service
Warning
This is a private member and should never be called directly.
- Parameters
service_class (ClassType) – The name of a valude service class.
count (int) – the number of service_class instances to start.
-
_store_pid
()¶ store_pid function for storing the scripts pid
Warning
This is a private member and should never be called directly.
- Note
This method writes a pidfile to
self.conf.PIDFILES
containing the pid value.
-
run
()¶ Main loop for lanching services. This is the main entry point for running the CLI.
Hint
This is the main entry point and how you should interact with this class
Example
Launcher().run()
- Raises
SystemExit – if any services fail to start.
-
-
exception
rtl.main.
StartError
(error)¶ Micro-service failed to start
-
rtl.main.
_service_wrapper
(service_class)¶ Call start on the the service inside the process.
Warning
This is a private member and should never be called directly.
- Parameters
service_class (ClassType) – The name of a valude service class.
- Raise:
StartError: if service failes to start.


{% extends "tutorial.html" %} {% block headauthor %}Ryan Seddon{% endblock %} {% block headtitle %}Introduction to JavaScript Source Maps{% endblock %} {% block pagetitle %}Introduction to JavaScript Source Maps{% endblock %} {% block pagebreadcrumb %}Introduction to JavaScript Source Maps{% endblock %} {% block date %}April 21, 2010{% endblock %} {% block browsersupport %} Operaunsupported Internet Explorerunsupported Safarisupported Firefoxsupported Chromesupported {% endblock %} {% block iscompatible %} {% endblock %} {% block head %} {% endblock %} {% block onload %}{% endblock %} {% block content %}
Have you ever found yourself wishing you could keep your client-side code readable and more importantly debuggable even after you've combined and minified it, without impacting performance? Well now you can through the magic of source maps.
Basically it's a way to map a combined/minified file back to an unbuilt state. When you build for production, along with minifying and combining your JavaScript files, you generate a source map which holds information about your original files. When you query a certain line and column number in your generated JavaScript you can do a lookup in the source map which returns the original location. Developer tools (currently WebKit nightly builds, Google Chrome, or Firefox 23+) can parse the source map automatically and make it appear as though you're running unminified and uncombined files.
Demo: Get original locationThe above demo allows you to right click anywhere in the textarea containing the generated source. Select "Get original location" will query the source map by passing in the generated line and column number, and return the position in the original code. Make sure your console is open so you can see the output.
Before you view the following real world implementation of Source Maps make sure you've enabled the source maps feature in either Chrome Canary or WebKit nightly by clicking the settings cog in the dev tools panel and checking the "Enable source maps" option. See screenshot below.
Firefox 23+ has source maps enabled by default in the built in dev tools. See screenshot below.
So... That Source Map query demo is cool and all but what about a real world use case? Take a look at the special build of font dragr at dev.fontdragr.com in Chrome Canary, WebKit nightly or Firefox 23+, with source mapping enabled, and you'll notice that the JavaScript isn't compiled and you can see all the individual JavaScript files it references. This is using source mapping, but behind the scenes actually running the compiled code. Any errors, logs and breakpoints will map to the dev code for awesome debugging! So in effect it gives you the illusion that you're running a dev site in production.
Demo: View scripts panel (with source maps) on fontdragr.comRight now source mapping is only working between uncompressed/combined JavaScript to compressed/uncombined JavaScript, but the future is looking bright with talks of compiled-to-JavaScript languages such as CoffeeScript and even the possibility of adding support for CSS preprocessors like SASS or LESS.
In the future we could easily use almost any language as though it were supported natively in the browser with source maps:
Take a look at this screencast of CoffeeScript being debugged in an experimental build of the Firefox console:
The Google Web Toolkit (GWT) has recently added support for Source Maps and Ray Cromwell of the GWT team did an awesome screencast showing source map support in action.
Another example I've put together uses Google's Traceur library which allows you to write ES6 (ECMAScript 6 or Next) and compile it to ES3 compatible code. The Traceur compiler also generates a source map. Take a look at this demo of ES6 traits and classes being used like they're supported natively in the browser, thanks to the source map. The textarea in the demo also allows you to write ES6 which will be compiled on the fly and generate a source map plus the equivalent ES3 code.
Demo: Write ES6, debug it, view source mapping in actionThe only JavaScript compiler/minifier that has support, at the moment, for source map generation is the Closure compiler. (I'll explain how to use it later.) Once you've combined and minified your JavaScript, alongside it will exist a sourcemap file. Currently, the Closure compiler doesn't add the special comment at the end that is required to signify to a browsers dev tools that a source map is available:
//# sourceMappingURL=/path/to/file.js.map
This enables developer tools to map calls back to their location in original source files. Previously the comment pragma was //@
but due to some issues with that and IE conditional compilation comments the decision was made to change it to //#
. Currently Chrome Canary, WebKit Nightly and Firefox 24+ support the new comment pragma. This syntax change also affects sourceURL.
If you don't like the idea of the weird comment you can alternatively set a special header on your compiled JavaScript file:
X-SourceMap: /path/to/file.js.map
Like the comment this will tell your source map consumer where to look for the source map associated with a JavaScript file. This header also gets around the issue of referencing source maps in languages that don't support single-line comments.
The source map file will only be downloaded if you have source maps enabled and your dev tools open. You'll also need to upload your original files so the dev tools can reference and display them when necessary.
Like I mentioned above you'll need to use the Closure compiler to minify, concat and generate a source map for your JavaScript files. The command is as follows:
java -jar compiler.jar \ --js script.js \ --create_source_map ./script-min.js.map \ --source_map_format=V3 \ --js_output_file script-min.js
The two important command flags are --create_source_map
and --source_map_format
. This is required as the default version is V2 and we only want to work with V3.
In order to better understand a source map we'll take a small example of a source map file that would be generated by the Closure compiler and dive into more detail on how the "mappings" section works. The following example is a slight variation from the V3 spec example.
{ version : 3, file: "out.js", sourceRoot : "", sources: ["foo.js", "bar.js"], names: ["src", "maps", "are", "fun"], mappings: "AAgBC,SAAQ,CAAEA" }
Above you can see that a source map is an object literal containing lots of juicy info:
Originally the source map spec had a very verbose output of all the mappings and resulted in the sourcemap being about 10 times the size of the generated code. Version two reduced that by around 50% and version three reduced it again by another 50%, so for a 133kB file you end up with a ~300kB source map. So how did they reduce the size while still maintaining the complex mappings?
VLQ (Variable Length Quantity) is used along with encoding the value into a Base64 value. The mappings property is a super big string. Within this string are semicolons (;) that represent a line number within the generated file. Within each line there are commas (,) that represent each segment within that line. Each of these segments is either 1, 4 or 5 in variable length fields. Some may appear longer but these contain continuation bits. Each segment builds upon the previous, which helps reduce the file size as each bit is relative to its previous segments.
Like I mentioned above each segment can be 1, 4 or 5 in variable length. This diagram is considered a variable length of four with one continuation bit (g). We'll break down this segment and show you how the source map works out the original location. The values shown above are purely the Base64 decoded values, there is some more processing to get their true values. Each segment usually works out five things:
Not every segment has a name, method name or argument, so segments throughout will switch between four and five variable length. The g value in the segment diagram above is what's called a continuation bit this allows for further optimisation in the Base64 VLQ decoding stage. A continuation bit allows you to build on a segment value so you can store big numbers without having to store a big number, a very clever space saving technique that has its roots in the midi format.
The above diagram AAgBC
once processed further would return 0, 0, 32, 16, 1 – the 32 being the continuation bit that helps build the following value of 16. B purely decoded in Base64 is 1. So the important values that are used are 0, 0, 16, 1. This then lets us know that line 1 (lines are kept count by the semi colons) column 0 of the generated file maps to file 0 (array of files 0 is foo.js), line 16 at column 1.
To show how the segments get decoded I will be referencing Mozilla's Source Map JavaScript library. You can also look at the WebKit dev tools source mapping code, also written in JavaScript.
In order to properly understand how we get the value 16 from B we need to have a basic understanding of bitwise operators and how the spec works for source mapping. The preceding digit, g, gets flagged as a continuation bit by comparing the digit (32) and the VLQ_CONTINUATION_BIT (binary 100000 or 32) by using the bitwise AND (&) operator.
32 & 32 = 32 // or 100000 | | V 100000
This returns a 1 in each bit position where both have it appear. So a Base64 decoded value of 33 & 32
would return 32 as they only share the 32 bit location as you can see in the above diagram. This then increases the the bit shift value by 5 for each preceding continuation bit. In the above case its only shifted by 5 once, so left shifting 1 (B) by 5.
1 << 5 // 32 // Shift the bit by 5 spots ______ | | V V 100001 = 100000 = 32
That value is then converted from a VLQ signed value by right shifting the number (32) one spot.
32 >> 1 // 16 //or 100000 | | V 010000 = 16
So there we have it: that is how you turn 1 into 16. This may seem an over complicated process, but once the numbers start getting bigger it makes more sense.
The spec mentions cross site script inclusion issues that could arise from the consumption of a source map. To mitigate this it's recommended that you prepend the first line of your source map with ")]}
" to deliberately invalidate JavaScript so a syntax error will be thrown. The WebKit dev tools can handle this already.
if (response.slice(0, 3) === ")]}") { response = response.substring(response.indexOf('\n')); }
As shown above, the first three characters are sliced to check if they match the syntax error in the spec and if so removes all characters leading up to the first new line entity (\n).
sourceURL
and displayName
in action: Eval and anonymous functionsWhile not part of the source map spec the following two conventions allow you to make development much easier when working with evals and anonymous functions.
The first helper looks very similar to the //# sourceMappingURL
property and is actually mentioned in the source map V3 spec. By including the following special comment in your code, which will be evaled, you can name evals so they appear as more logical names in your dev tools. Check out a simple demo using the CoffeeScript compiler:
Demo: See eval()
'd code show as a script via sourceURL
//# sourceURL=sqrt.coffee
The other helper allows you to name anonymous functions by using the displayName
property available on the current context of the anonymous function. Profile the following demo to see the displayName
property in action.
btns[0].addEventListener("click", function(e) { var fn = function() { console.log("You clicked button number: 1"); }; fn.displayName = "Anonymous function of button 1"; return fn(); }, false);
When profiling your code within the dev tools the displayName
property will be shown rather than something like (anonymous)
. However displayName is pretty much dead in the water and won't be making it into Chrome. But all hope isn't lost and a much better proposal has been suggested called debugName.
As of writing the eval naming is only available in Firefox and WebKit browsers. The displayName
property is only in WebKit nightlies.
Currently there is very lengthy discussion on source map support being added to CoffeeScript. Go check out the issue and add your support for getting source map generation added to the CoffeeScript compiler. This will be a huge win for CoffeeScript and its devoted followers.
UglifyJS also has a source map issue you should take a look at too.
Lot's of tools generate source maps, including the coffeescript compiler. I consider this a moot point now.
The more tools available to us that can generate a source maps the better off we'll be, so go forth and ask or add source map support to your favourite open source project.
One thing Source Maps doesn't cater for right now is watch expressions. The problem is that trying to inspect an argument or variable name within the current execution context won't return anything as it doesn't really exist. This would require some sort of reverse mapping to lookup the real name of the argument/variable you wish to inspect compared to the actual argument/variable name in your compiled JavaScript.
This of course is a solvable problem and with more attention on source maps we can start seeing some amazing features and better stability.
Recently jQuery 1.9 added support for source maps when served off of offical CDNs. It also pointed a peculiar bug when IE conditional compilation comments (//@cc_on) are used before jQuery loads. There has since been a commit to mitigate this by wrapping the sourceMappingURL in a multi-line comment. Lesson to be learned don't use conditional comment.
This has since been addressed with the changing of the syntax to //#
.
Here's some further resources and tools you should check out:
Source maps are a very powerful utility in a developer's tool set. It's super useful to be able to keep your web app lean but easily debuggable. It's also a very powerful learning tool for newer developers to see how experienced devs structure and write their apps without having to wade through unreadable minified code. What are you waiting for? Start generating source maps for all projects now!
{% endblock %}


Admittedly, I struggled with this cube for quite some time before realizing that it was simply a shape-mod of the classic Rubik's Cube. I think the shape may lend itself to helping one think about solving the Rubik's cube in some, perhaps, unorthodox ways, but I've never been cleaver enough to discover any such thing.
Just do a classic layer-solve for the first two layers, accounting for center-peice orientation. The only interesting part of the solve is the last layer, which is addressed in the next step.
Like the Fisher cube, part of the difficulty stems from not being able to recognize the proper orientation of peices of the puzzle due to the shape modification. Specifically, we can't recognize the orientation of two of the corner peices in the final layer. What adds to difficulty here beyond the Fisher Cube, however, is that we also can't easily recognize the proper orientation or position of the edge peices in the final layer. This, of course, is also due to the shape modification.
Properly orient the center peice of the top layer.
Permute the edge peices so that the colors are consistent with the center, even if orientations are off. Now try fixing the orientation with a standard move to do so. This will take them out of proper position, so then just permute them back into proper position with respect to color against the center peice. Everything usually solves, as far as the edges and center are concerned, on the second permutation of the edges. If not, just repeat.
Position and orient the corners as usual. If a single corner is misoriented, it just means you must re-orient it along with one of the orientation-neutral corners.


Hello there
This is the API for the Nautilist Project
Docs coming soon
/api/projects
/api/collections


THE GAME (Polygram) Starring: Michael Douglas, Deborah Kara Unger, Sean Penn, James Rebhorn. Screenplay: John Brancato and Michael Ferris. Producers: Steve Golin and Cean Chaffin. Director: David Fincher. MPAA Rating: R (profanity, adult themes, intense situations) Running Time: 123 minutes. Reviewed by Scott Renshaw.
There are bound to be fans of SEVEN who will view director David Fincher's follow-up project, THE GAME, as a sell-out...but then again, where was there to go from SEVEN? Fincher's 1995 thriller may have been the decade's most baffling blockbuster -- a horrifying, unnerving, bleak vision of millennial dread which was everything a Hollywood success wasn't supposed to be, yet still somehow made $100 million. It left viewers shaken and emotionally drained like nothing in recent memory. If Fincher had decided to remake THE EXORCIST for his next project, someone would have accused him of going soft.
The wonderfully surprising thing about THE GAME is that it may be the best choice Fincher could have made. Free from the ridiculous expectations of ALIEN3 and the off-putting subject matter of SEVEN, Fincher might finally be recognized as the most gifted director of suspense films working today. THE GAME is a gripping, dizzying and thoroughly entertaining thriller which bears no resemblance whatsoever to SEVEN, except in the obvious talent of the director.
 Enter Nick's black sheep brother Conrad (Sean Penn), with a special 48th birthday present for the man who has everything: a gift certificate to a mysterious enterprise called Consumer Recreation Services. Once signed up, Nick learns that he will be participating in a specially-designed game with unknown rules and an unknown object. He's not even sure when -- or if -- it will begin.
And for the audience, that's half the fun. Fincher wrings an unbelievable amount of tension out of the likelihood that something will happen, even though nothing is actually happening. As Nick strides through an airport shortly after receiving his first clue in the game, the confident businessman slowly begins to see every person as a potential participant, every mundane action or object as potentially loaded with significance. The mere idea of loss of control drives Nick nuts; the game is playing him even before it begins.
Then the game does begin, and Fincher tightens the screws psychologically as well as viscerally. As tautly as he can fashion a chase or an action sequence, he's even better at creating a pervasive atmosphere of impending doom, or the unsettling possibility that literally anything could happen next. If action/suspense films, according to the popular metaphor, are roller-coasters, Fincher's ride is a suspended roller-coaster: not only are you moving at breakneck speed, you can't even see the track to anticipate which way you're going to turn. That's saying quite a lot because, if you think about it carefully, you'll realize there's really only one way the film can pay off. Even though you may know where THE GAME ultimately will end up, Fincher makes sure you don't know how you're going to get there.
THE GAME's somewhat predictable script comes from the team of John Brancato and Michael Ferris, who sent Sandra Bullock through similar Everyperson-in-peril paces in THE NET. Don't let that keep you away. Michael Douglas' characteristic intensity and determination give THE GAME an edge Bullock couldn't muster, while Fincher sets up even simple shots with a shudder-inducing elegance (I'm not sure I've seen an elevator door open with more menace than it does in THE GAME, and that includes THE SHINING). This time, however, it's possible to enjoy Fincher's shudders with a smile. THE GAME may not be as profound an experience as SEVEN, but it's a more satisfying one. If this is David Fincher's idea of selling out, I hope folks are buying. We may be looking at the emergence of this generation's Hitchcock.
On the Renshaw scale of 0 to 10 game set matches: 9.
Visit Scott Renshaw's MoviePage http://www.inconnect.com/~renshaw/ *** Subscribe to receive new reviews directly by email! See the MoviePage for details, or reply to this message with subject line "Subscribe".
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


Check Out
Action One:
The Birth of Action
PG-13
BUY TICKETS
Action Two:
Action Gets Bigger
Rated R
BUY TICKETS
Bruce Willis:
The True Story
Rated PG
BUY TICKETS
×
Modal title
Test test test test
×
Action Two
Come see the most critically acclaimed movie of
ALL TIME
Name
Email address
10 AM
12 PM
4 PM
8 PM
11:30 PM
No Discount
Senior Discount
Child Discount
Close
Add to cart
×
Modal title
Test test test test333
Name
Email address
10 AM
12 PM
4 PM
8 PM
11:30 PM
No Discount
Senior Discount
Child Discount
Close
Add to cart
×
Check Out
Credit Card Info
Close
Checkout


11.3. Graph Traversals (WORK IN PROGRESS)¶
11.3.1. Graph Traversals¶
Many graph applications need to visit the vertices of a graph in some specific order based on the graph’s topology. This is known as a graph traversal and is similar in concept to a tree traversal. Recall that tree traversals visit every node exactly once, in some specified order such as preorder, inorder, or postorder. Multiple tree traversals exist because various applications require the nodes to be visited in a particular order. For example, to print a BST’s nodes in ascending order requires an inorder traversal as opposed to some other traversal. Standard graph traversal orders also exist. Each is appropriate for solving certain problems. For example, many problems in artificial intelligence programming are modeled using graphs. The problem domain might consist of a large collection of states, with connections between various pairs of states. Solving this sort of problem requires getting from a specified start state to a specified goal state by moving between states only through the connections. Typically, the start and goal states are not directly connected. To solve this problem, the vertices of the graph must be searched in some organized manner.
Graph traversal algorithms typically begin with a start vertex and attempt to visit the remaining vertices from there. Graph traversals must deal with a number of troublesome cases. First, it might not be possible to reach all vertices from the start vertex. This occurs when the graph is not connected. Second, the graph might contain cycles, and we must make sure that cycles do not cause the algorithm to go into an infinite loop.
Graph traversal algorithms can solve both of these problems
by flagging vertices as VISITED
when appropriate.
At the beginning of the algorithm, no vertex is flagged as VISITED
.
The flag for a vertex is set when the vertex is first visited
during the traversal.
If a flagged vertex is encountered during traversal, it is not visited
a second time.
This keeps the program from going into an infinite loop when it
encounters a cycle.
Once the traversal algorithm completes, we can check to see if all
vertices have been processed by checking whether they have the
VISITED
flag set.
If not all vertices are flagged,
we can continue the traversal from another unvisited vertex.
Note that this process works regardless of whether the graph is
directed or undirected.
To ensure visiting all vertices, graphTraverse
could be called
as follows on a graph \(\mathbf{G}\):
static void graphTraverse(Graph G) {
int v;
for (v=0; v<G.nodeCount(); v++) {
G.setValue(v, null); // Initialize
}
for (v=0; v<G.nodeCount(); v++) {
if (G.getValue(v) != VISITED) {
doTraversal(G, v);
}
}
}
def graphTraverse(G):
for v in range(G.nodeCount()): # Initialize
G.setValue(v, None)
for v in range(G.nodeCount()): # Traverse
if G.getValue(v) != VISITED:
doTraversal(G, v)
Function doTraversal
might be implemented by using
one of the graph traversals described next.
<IP_ADDRESS>. Depth-First Search¶
Our first method for organized graph traversal is called depth-first search (DFS). Whenever a vertex \(v\) is visited during the search, DFS will recursively visit all of \(v\) ‘s unvisited neighbors. Equivalently, DFS will add all edges leading out of \(v\) to a stack. The next vertex to be visited is determined by popping the stack and following that edge. The effect is to follow one branch through the graph to its conclusion, then it will back up and follow another branch, and so on. The DFS process can be used to define a depth-first search tree. This tree is composed of the edges that were followed to any new (unvisited) vertex during the traversal, and leaves out the edges that lead to already visited vertices. DFS can be applied to directed or undirected graphs.
This visualization shows a graph and the result of performing a DFS on it, resulting in a depth-first search tree.
Here is an implementation for the DFS algorithm.
static void DFS(Graph G, int v) {
PreVisit(G, v);
G.setValue(v, VISITED);
int[] nList = G.neighbors(v);
for (int i=0; i< nList.length; i++) {
if (G.getValue(nList[i]) != VISITED) {
DFS(G, nList[i]);
}
}
PostVisit(G, v);
}
def DFS(G, v):
PreVisit(G, v)
G.setValue(v, VISITED)
for n in G.neighbors(v):
if G.getValue(n) != VISITED:
DFS(G, n)
PostVisit(G, v)
This implementation contains calls to functions PreVisit
and
PostVisit
.
These functions specify what activity should take place during the
search.
Just as a preorder tree traversal requires action before the subtrees
are visited, some graph traversals require that a vertex be processed
before ones further along in the DFS.
Alternatively, some applications require activity after the
remaining vertices are processed; hence the call to function
PostVisit
.
This would be a natural opportunity to make use of the
visitor design pattern.
The following visualization shows a random graph each time that you start it, so that you can see the behavior on different examples. It can show you DFS run on a directed graph or an undirected graph. Be sure to look at an example for each type of graph.
DFS processes each edge once in a directed graph. In an undirected graph, DFS processes each edge from both directions. Each vertex must be visited, but only once, so the total cost is \(\Theta(|\mathbf{V}| + |\mathbf{E}|)\).
Here is an exercise for you to practice DFS.
11.3.2. Breadth-First Search¶
Our second graph traversal algorithm is known as a breadth-first search (BFS). BFS examines all vertices connected to the start vertex before visiting vertices further away. BFS is implemented similarly to DFS, except that a queue replaces the recursion stack. Note that if the graph is a tree and the start vertex is at the root, BFS is equivalent to visiting vertices level by level from top to bottom.
This visualization shows a graph and the result of performing a BFS on it, resulting in a breadth-first search tree.
Here is an implementation for BFS.
static void BFS(Graph G, int v) {
LQueue Q = new LQueue(G.nodeCount());
Q.enqueue(v);
G.setValue(v, VISITED);
while (Q.length() > 0) { // Process each vertex on Q
v = (Integer)Q.dequeue();
PreVisit(G, v);
int[] nList = G.neighbors(v);
for (int i=0; i< nList.length; i++) {
if (G.getValue(nList[i]) != VISITED) { // Put neighbors on Q
G.setValue(nList[i], VISITED);
Q.enqueue(nList[i]);
}
}
PostVisit(G, v);
}
}
def BFS(G, v):
Q = new LQueue(G.nodeCount())
Q.enqueue(v)
G.setValue(v, VISITED)
while Q.length() > 0: # Process each vertex on Q
v = Q.dequeue()
PreVisit(G, v)
for n in G.neighbors(v):
if G.getValue(n) != VISITED: # Put neighbors on Q
G.setValue(n, VISITED)
Q.enqueue(n)
PostVisit(G, v)
The following visualization shows a random graph each time that you start it, so that you can see the behavior on different examples. It can show you BFS run on a directed graph or an undirected graph. Be sure to look at an example for each type of graph.
Here is an exercise for you to practice BFS.
Todo
- type: Exercise
Summary exercise for graph traversals.


You will be thrilled to learn that Mr Key has returned to Blighty after his frolics on foreign shores.
I did manage to drag my bones to Resonance yesterday to declaim prose into a microphone for thirty minutes, and I cobbled together an anecdote about my holiday for The Dabbler. Other than that, prose has failed to pour out of me. Further dispatches from Hooting Yard soon, God willing.


And then what?
Heatscore Orange:
The lights in your room will start to blink as a first warning
Heatscore Red:
Coolio will lower the room temperature to literally cool down the discussion
Heatscore Lockdown:
Your office gets notified to deliver the first aid Coolio Kit: Beer!


The 100 Best Web Design Tools Ever
Based on this infographic by Illustrio
We thought it would be cool to have one place where all of these awesome tools could live. Also,we loved what Illustro did with compiling all of these web design tools into an infographic. jbirds.co thought it would be great if that infographic were interactive. This is an angular app that allows you to search their resource list by a category title or the name of a web design tool.
This was quite a bit of information to port into a JSON file, so if you see any spelling mistakes or broken links, call me out.


Hello, and welcome to this new site.  :(
This will be the temporary home of HarpNet for now. We are almost ready to transfer to a real domain! Soon™
Enjoy!
What we do
We are HarpNet Studios, a game design company that makes games (NO WAY!)
Our goal is to make open source games for all to enjoy. If you like our stuff, please spread the word!
That's what we do.
Why we do it
Well, we want to make everyone happy!
We love good games as much as any person and we hope to work with YOU on making our games great.
Also, we all think open-source is the way to go for games.
That's why we do it.

If you would like to join, please fill out a team application. (Look up. ^^^)
Where we are located
All the places. No, really, HarpNet Studios has members from all around the globe.
Most of us in the United States, however some live as far away as the UK and beyond!
Once we get enough money (It's always about the money, isn't it...), we plan to rent an office building for our continued ventures.
Share our site
Thanks for reading! Please, do spread the word, it means a lot to us.
In the future we will have donations set up, but PayPal is annoying.
Here are some ways to share our site.


Balmain
Black Leather Biker Jacket
Supple leather biker jacket in black. Silver-tone hardware. Band collar fastened at press-stud closure. Ribbed detailing at shoulders.
 The stuff you have that isn't noticed first, but can't be ignored. We pay attention to it. We argue about it. We work day and night to make the little shit as good as it can be, so when you wear it, you feel like you've got a leg up on the rest of the world.


Frontal and lateral views of the skull, chest, abdomen, and spine, bilateral oblique views of the ribs, and frontal views of the upper and lower extremities obtained according to the guidelines for the American College of Radiology for the investigation of possible child abuse are submitted for interpretation.
None.
Fractures:
Other bony abnormality:
Soft tissues:
Bone density:
Bone age:
Normal.
Communication of findings:


Home
Profile
Switch to List View
Logout
copyright Mandar Gade, Neha Kumar, Varun Shah, Setu Pandya, San Jose State University


Previous: Programming Aids, Up: Top
This chapter describes the larger applications included with Distel.


Caleta de Fustes lies on the east coast of Fuerteventura. It is one of the main tourist towns on the island.
Position 28°23.3'N, 13°51.1'W.
Entrance to the marina can be difficult for those unfamilair with the outlying dangers. Reefs extend half a mile offshore, both from the harbour wall and the southern shore of the bay.
Navigation buoys mark the southern extremity of the offshore reef and also the eastern extremity of the shallow ground to the west of the port entrance.
Night entrance should be avoided.
To be safe, yachts coming from the north should keep between half and one mile offshore and sail well south of the marina entrance before turning to enter. The marina advises that a course of 355deg should be sailed in the final approaches.
The marina monitors VHF channels 9 and 16 between office hours (09:00-20:00) and will give advice on the approaches if requested.
There is one main floating pontoon with fingers as well as a pontoon alongside the quay.
Yachts larger than 16 metres should reserve a slip in advance. If no prior arrangements made, tie up at the fuel dock on the main quay until a berth can be arranged.


--- layout: page title: About Us description: background: '/img/about-us-6.jpg' ---
We are a team of industry professionals with a passion for all things digital! We have been partnered with Measurement Canada, a federal department whose mandate is to ensure all commercial measurement tools abide by federal regulations and standards to protect Canadians from unfair trade. We are excited at the opportunity to work with our partners to bring digital innovation and transformation to such an impactful organization!
You can learn a bit more about each of us below:
I am a professionally licensed engineer with eight years of industry experience. Prior to joining Code 4 Canada, I worked in a software startup called SceneDoc, where we delivered a mobile criminal case management system for law enforcement agencies around the world! During my time at SceneDoc, I was able to successfully organically grow the company to the point where we were successfully acquired by Tyler Technologies (NYSE: TYL), the largest publicly traded company in Public Safety.
I am now bringing my expertise into the CivicTech world, and I'm excited to bring digital transformation and innovation for the betterment of Canadians at a national level.
Always happy to connect via LinkedIn to chat!
Ramis has experience working with agencies, startups, and enterprise companies. He specializes in working with stakeholders and product teams to create thoughtful interfaces, whether digital or otherwise.
His personal goal is to design artifacts that make the user’s life easier, and hopefully, more joyful!
Ramis is excited for the opportunity to help the public sector flourish by combining agile methodologies and design thinking to create innovative products and services.
Noor is a software developer with a flair for innovating traditional workflows. He helps clients demystify the benefits of data driven decision making, and believes empathy is an essential part of creating products users find valuable.
Noor is a contributor to the Sadaat Aid Foundation, working to remove financial obstacles for students and break the cycle of poverty.
He believes greater the digital outreach from government will increase the number of engaged Canadians, helping to elevate voices that are not typically heard.


layout: true class: slide
--- class: center,middle # PokitDok API Overview ### SF Healthcare Data & API Meetup #### John Riney, Technical Evangelist, PokitDok --- # GET /index ### What we do ### Why we do it ### Code ### Resources --- class: center,middle .center[
] --- class: center,middle # The operating system # for digital health. --- class: center,middle ### Insurance company (payer) stuff ### Curated data stuff ### Interoperability stuff --- # Insurance company stuff
Eligibility (coverage, plan structure, deductibles)
Claims and claims status
Enrollment
Authorizations
Referrals
### ... AKA ASC X12 --- # X12 Eligibility request ```html HL*1**20*1~NM1*PR*2*Premium Gold Insurance Co.*****PI*0123456~HL*2*1*21*1~NM1*1P* 1*Back*Has*Your***XX*9876543210~HL*3*2*22*0~TRN*1*89368DC6A14E4E529AA876ED416E8A9F *1453915417~NM1*IL*1*A-lot*Lifts****MI*MEM10001~DMG*D8*19820315*M~EQ*98^33~ ``` --- # Our Eligibility request ```javascript { "member": { "birth_date": "1982-03-15", "first_name": "Lifts", "last_name": "A-Lot", "id": "MEM10001" }, "provider": { "first_name": "Has-Your", "last_name": "Back", "npi": "9876543210" }, "service_types": ["professional_physician_visit_office", "chiropractic"], "trading_partner_id": "premium_gold_insurance" } ``` --- # X12 Eligibility response ```html HL*1**20*1~NM1*PR*2*Premium Gold Insurance Co.*****PI*0123456~HL*2*1*21*1~NM1*1P* 1*Back*Has*Your***XX*9876543210~HL*3*2*22*0~TRN*2*89368DC6A14E4E529AA876ED416E8A9F*<PHONE_NUMBER>NM1*IL*1*A-lot*Lifts****MI*MEM10001~N3*2150 Pleasant Drive~N4*Sunny*CA* 900010001~DMG*D8*19820315*M~DTP*291*D8*20141001~EB*B**98****10~EB*A**33*****.20~ ``` ### oh God make it stop --- # Our Eligibility response ```javascript { "coverage": [ "coinsurance": [ { "benefit_percent": 0.2, "service_types": [ "chiropractic" ] } ], "copay": { "copayment": { "amount": "10", "currency": "USD" }, "service_types": [ "professional_physician_visit_office" ] } ], "plan_begin_date": "2014-10-01", (...and so on...) } ``` --- # Hot tech from 1979 .center[
] --- class: center,middle # Also from 1979? --- class: center,middle # All that X12 crap --- # Curated data stuff
Provider search
Medical procedure code (CPT)
Cash and insurance procedure prices
Payers and plans
--- # Interop stuff
Integration with EMR/EHR systems, such as...
Scheduling
CCD (Continuity of care documents)
Identity management
These require some customization, though. --- class: center middle # Kind of a lot --- class: center,middle # BECAUSE GRAPHS .center[
] --- class: center,middle # We are not Health IT .center[
] --- # We're a real API company ### no hidden pricing ### no certification or "app stores" ### no stupid contracts to get started ### no paid docs (yes that's a thing) --- class: center,middle # Get to the code already --- # Resources #### Platform site [platform.pokitdok.com](https://platform.pokitdok.com) #### API Docs [platform.pokitdok.com/documentation/v4](https://platform.pokitdok.com/documentation/v4) #### Github [github.com/pokitdok](https://github.com/pokitdok) #### These slides [github.com/riney/slide-decks/sf_healthcare_api_meetup](https://github.com/riney/slide-decks/tree/master/sf_healthcare_api_meetup_2015) --- # Backup --- # Code samples #### Setup ```python import pokitdok pd = pokitdok.api.connect('
', '
') ``` #### Provider search ```python #retrieve provider information by NPI pd.providers(npi='1467560003') #search providers by name (individuals) pd.providers(first_name='Jerome', last_name='Aya-Ay') #search providers by name (organizations) pd.providers(organization_name='Qliance') #search providers by location and/or specialty pd.providers(zipcode='29307', radius='10mi') pd.providers(zipcode='29307', radius='10mi', specialty='RHEUMATOLOGY') ``` --- #### Eligibility ```python pd.eligibility({ "member": { "birth_date": "1970-01-01", "first_name": "Jane", "last_name": "Doe", "id": "W000000000" }, "provider": { "first_name": "JEROME", "last_name": "AYA-AY", "npi": "1467560003" }, "service_types": ["health_benefit_plan_coverage"], "trading_partner_id": "MOCKPAYER" }) ``` #### Cash and insurance prices ```python #retrieve cash price information by zip and CPT code pd.cash_prices(zip_code='32218', cpt_code='87799') #retrieve insurance price information by zip and CPT code pd.insurance_prices(zip_code='32218', cpt_code='87799') ```


This subpart provides policy and procedures for the establishment and use of electronic commerce in Federal acquisition as required by 41 U.S.C. 2301.
(a) The Federal Government shall use electronic commerce whenever practicable or cost-effective. The use of terms commonly associated with paper transactions (e.g., “copy,” “document,” “page,” “printed,” “sealed envelope,” and “stamped”) shall not be interpreted to restrict the use of electronic commerce. Contracting officers may supplement electronic transactions by using other media to meet the requirements of any contract action governed by the FAR (e.g., transmit hard copy of drawings).
(b) Agencies may exercise broad discretion in selecting the hardware and software that will be used in conducting electronic commerce. However, as required by 41 U.S.C. 2301, the head of each agency, after consulting with the Administrator of OFPP, shall ensure that systems, technologies, procedures, and processes used by the agency to conduct electronic commerce—
(1) Are implemented uniformly throughout the agency, to the maximum extent practicable;
(2) Are implemented only after considering the full or partial use of existing infrastructures;
(3) Facilitate access to Government acquisition opportunities by small business concerns, small disadvantaged business concerns, women-owned, veteran-owned, HUBZone, and service-disabled veteran-owned small business concerns;
(4) Include a single means of providing widespread public notice of acquisition opportunities through the Governmentwide point of entry and a means of responding to notices or solicitations electronically; and
(5) Comply with nationally and internationally recognized standards that broaden interoperability and ease the electronic interchange of information, such as standards established by the National Institute of Standards and Technology.
(c) Before using electronic commerce, the agency head shall ensure that the agency systems are capable of ensuring authentication and confidentiality commensurate with the risk and magnitude of the harm from loss, misuse, or unauthorized access to or modification of the information.
(d) Agencies may accept electronic signatures and records in connection with Government contracts.


Agency Manager
PLAY
STATISTICS
SETTINGS
Create Site
Sites
Destroy Site
Site Designation
Date Created
Location
Anomalies Contained
Transfer Anomaly
Anomalies
Neutralize Anomaly
Anomaly Designation
Date Discovered
Object Class
Contained At


?6
7
8
9
10
v
The
New
York
copyright
reserved
botanical
Garden
PLANTS
OF
DOMINICAN
REPUBLIC
POACEAE
/2Ay
HcJrIoJ'.fbrv
rv\
r<2/)CLy\S
(U/Hlct.)
C.£
UvM.
cbu/-.
S.
A.
ft?Z.
DOMINICAN
REPUBLIC:
Prov.
Pedernales:
37
km
N
of
Cabo
Rojo.
18¡09,N,
71¡35'W.
Alt.
1480
m.
Grassland
with
scattered
pines.
Inflorescence
red.
Sue
A.
Thompson
7^72
John
E.
Rawlins
and
Chen
Young
HERBARIUM.
CARNEGIE
MUSEUM
(CM),
PITTSBURGH,
PA.
22
July
1990
1604075
Legend -
Level of confidence that token is an accurately-transcribed word
extremely low
very low
low
undetermined
medium
high
very high