Hey Guys,
I have built my EmonTX and currently have it using 2 CT sensors for Solar. I now want to monitor and control my solar water heating. I will be using the the temperature sensor port, but want to know which other DIO are available and not in use in the emonTX that I could use, And Could I use the the pulse sensor as a DIO ? would I need to change anything on the PCB ?
Shot!
Re: Unused DIO ?
The Atmel processor on the emonTx has 20 i/o pins: 14 digital and 6 analog. Two of them (D0 & D1) are tied up with the Serial i/f, so that leaves 18 for general use.
Five of the digital pins, numbers 2 and 10 - 13, are used by the RFM12, and D4 is used by the temp sensor.
The Atmel has two digital pins which can be configured for interrupts: D2 which is used by the RFM12, and D3. D3 is pre-wired for use as a pulse counter but can be re-used for other purposes if desired, it being available at each of ports P1 - P4.
The five digital pins 5 - 9 inclusive are not reserved for anything and are therefore available for use. Connection may be made to them at Ports P1 to P4 and in the SPI/ISP zone.
The emonTx provides signal conditioning circuits for four of the analog channels: A2 for voltage, and A0, A2 and A3 for the three CTs. If not required for this purpose, these pins can be used for alternative purposes, via ports P1 - P4.
Analog pins 4 and 5 are unused on the emonTx, they being available in the 8-way port that's just above the FTDI programming header as SDA and SDK. To use them as digital pins, they need to be addressed as pins 14 -19.
The location of all i/o pins is nicely shown on the marked-up photo which Robert has added into my Mk2 PV Router build notes.
Hope this is of use!
Re: Unused DIO ?
Thanks for the respone.
With D3 being pre-wired for the pulse counter, I want to use this 3.5mm jack to supply the 5v,GND and IO to the relay, would I need to change the resistor in the zone or would it work as is with a sketch ?
Re: Unused DIO ?
From the Solderpad Schematic, the only resistor in the pulse-counter circuit is the 10K pulldown resistor, R8. If using D3 to drive a relay instead, I can't see this resistor being of any use to you, so it should be omitted.
If the current to drive your relay is only small, then you should be able to connect it directly between D3 and one of the power rails, all of which are available at the jack-socket. But if it takes more current than the processor can deliver, you may need to add a transistor stage to boost the signal.
Re: Unused DIO ?
Shot !,
If I am not mistaken the relay has a 2N2222 digital switch, and require 15ma-20ma to activate it, I will test though and see how it goes.


--- layout: post status: publish published: true title: New Releases author: display_name: Tomas Restrepo login: tomasr email<EMAIL_ADDRESS>url: http://winterdom.com/ author_login: tomasr author_email<EMAIL_ADDRESS>author_url: http://winterdom.com/ wordpress_id: 462 wordpress_url: http://winterdom.com/2006/11/newreleases date: '2006-11-07 10:33:11 +0000' date_gmt: '2006-11-07 10:33:11 +0000' categories: - ".NET" - BizTalk - WinFX tags: [] comments: - id: 324 author: Niklas Engfelt author_email: '' author_url: '' date: '2006-11-08 13:43:13 +0000' date_gmt: '2006-11-08 13:43:13 +0000' content: | BizTalk and HIS are quite connected. I think that's why they call HIS 2006. It was supposed to be released somewhere near BizTalk 2006 I believe too. Best regards Niklas ---
I'm in Lima, Peru all this week, so probably won't be able to blog much. Meanwhile, several important releases are coming out:
Technorati: .NET, BizTalk. HIS


About
Last Updated: May 5, 2020
So what’s ACF all about then?
Academic Competition Federation (ACF) is a non-profit organization dedicated to providing high-quality collegiate quizbowl tournaments. We are entirely student and volunteer run. We pride ourselves on the highest standard of academic question writing and we keep the amount of pop culture (a.k.a. trash) or semi-academic questions to a minimum.
We offer four tournaments throughout the academic year, roughly corresponding to a four-point difficulty scale:
- ACF Fall is an novice event that is held in mid-October. It is aimed at players new to collegiate quizbowl and those without significant high school quizbowl experience.
- ACF Winter is a medium-difficulty event that is held in mid-October. It aims to be appropriate for both new players and experienced ones alike.
- ACF Regionals is a regional championship event that is held in January/February. It serves as a qualifier for ACF Nationals.
- ACF Nationals is the premier collegiate national championship. It is held in April. To participate in ACF Nationals, teams must qualify through their performance at ACF Regionals, or may apply for wildcard bids.
Who can play in ACF tournaments?
You and your teammates must be:
- all attending the same school
- all taking at least one class for credit during the school year.
If you are not sure whether you are eligible, refer to the official ACF eligibility rules or write to ACF’s eligibility committee.
“Mixed” teams are not allowed to play ACF tournaments, i.e. teams containing players not all from one school. The head editor of the tournament may make an exception; however, these dispensations are made only in very limited circumstances. ACF reserves the right to disallow any team from playing at one of its tournaments.
ACF tournaments are generally held for college teams; however, ACF does, in limited circumstances, allow high school teams to play ACF Fall and ACF Regionals.
How can I become an ACF Member?
Twice a year (once before Regionals and once after Nationals), ACF invites community members who have done work for ACF in the prior year (either by editing an ACF tournament, or contributing to the logistics of running ACF tournaments) to become provisional members of ACF. Provisional members can then become full members of ACF by satisfactorily completing work on another ACF project.
To work with ACF, be on the lookout for an application to edit an ACF tournament over the prior summer, or contact an ACF board member about logistical work.
Donating to ACF
Please see this page for information on donating to ACF.
About this site
Site built using Jekyll (theme is Swiss by Diana Mounter) and hosted using GitHub Pages.


--- title: COVID-19 Symptom Surveys through Google author: Ryan Tibshirani date: 2020-09-18 tags: - symptom surveys - COVIDcast - R authors: - ryan heroImage: blog-lg-img_google-survey-post.jpg heroImageThumb: blog-thumb-img_google-survey-post.jpg summary: | Since April 2020, in addition to our massive daily survey advertised on Facebook, we've been running (even-more-massive) surveys through Google to track the spread of COVID-19 in the United States. At its peak, our Google survey was taken by over 1.2 million people in a single day, and over its first month in operation, averaged over 600,000 daily respondents. In mid-May, we paused daily dissemination of this survey in order to focus on our (longer, more complex) survey through Facebook, but we plan to bring back the Google survey this fall. This short post covers some key differences between our Google and Facebook surveys, explains the backstory behind the "CLI-in-community" question as it arose through our collaboration with Google, and shares some of our thinking about next steps for the Google survey. acknowledgements: | Ryan Tibshirani wrote the initial code for producing estimates from the aggregated survey data. Sangwon Hyun, Natalia Lombardi de Oliveira, and Lester Mackey greatly extended and improved this codebase, and they developed, along with Ryan, the underlying statistical methodology. Ryan came up with the idea of running the surveys, and worked with Google to make this a reality. On the Google side, Brett Slatkin and Hal Varian have been key collaborators; Brett wrote the code to get daily survey data over to Delphi's estimation pipeline; and both contributed numerous important ideas at various stages of the project. output: html_document: code_folding: hide blogdown::html_page: toc: true ---
Since April 2020, in addition to our {{< reflink "2020-08-26-fb-survey" "massive daily survey advertised on Facebook" >}}, we’ve been running (even-more-massive) surveys through Google to track the spread of COVID-19 in the United States. At its peak, our Google survey was taken by over 1.2 million people in a single day, and over its first month in operation, averaged about 600,000 daily respondents. As usual, we make aggregated data from this survey available through our {{< apireflink "api/covidcast.html" "COVIDcast API" >}}.
In mid-May, we decided to pause daily dissemination of this survey in order to focus on our (longer, more complex) survey through Facebook, but we plan to bring back the Google survey this fall. The two surveys are, in fact, quite different and complement each other nicely. This short post covers some key differences between our Google and Facebook surveys, explains the backstory behind the “CLI-in-community” question as it arose through our collaboration with Google’s team, and shares some of our thinking about next steps for the Google survey.
Back in March 2020, around the time we began discussions with Facebook about COVID-19 symptom surveys, we pitched the same idea to Google. Our motivation, {{< reflink "2020-08-26-fb-survey#why-run-these-surveys" "as we explained in our last post" >}}, has been to produce real-time, county-level data streams of self-reported COVID symptoms that can potentially serve as early indicators of COVID activity in the US. As we noted in that post, we weren’t the only data scientists who thought of running COVID-19 symptom surveys, and several other groups had deployed surveys before us. What distinguished our strategy from others’ was the pursuit of a giant like Google to achieve widespread and continuous dissemination (well beyond what we could do ourselves). Google’s willingness to help was a huge win for us. Of all the partnerships we formed to create new COVID-19 indicators, our deal with Google was the first to come through. This gave us an invaluable confidence boost, and taught us the silver lining of this pandemic: that many people are truly generous and willing to help. Google’s contributions didn’t stop there—they have been helping us in various ways ever since.
Our initial survey with Google launched in late March, deployed through various websites and apps (with whom Google partners to run questionnaires). Each respondent opted-in to answering the survey and agreed to legal disclosures about how the data would be used. The survey asked just a single question:
Do you or anyone in your household have a fever of at least 100 °F, along with cough, shortness of breath, or difficulty breathing?
This pattern of symptoms defines a condition called COVID-like illness or CLI. A respondent could reply “Yes”, “No”, or “Prefer not to say”. We’re also given the respondent’s (inferred) county from IP address lookup. At the start, this survey data allowed us to estimate the daily % CLI, the percentage of people with COVID-like illness, in over 1,000 counties across the US. After about 2 weeks, we stopped the survey. Google wondered whether we could get equally useful information without asking a question of such a sensitive nature. In general, asking a person about their health (or their family’s health) is not common practice on Google’s survey platform. The hope was that asking a broader question might also improve response rates, reduce costs, and increase the number of potential respondents.
Working with Brett Slatkin (head of Google Surveys) and Hal Varian (Google’s Chief Economist), we looked for a new question. Brett came up with a list of questions that were acceptable, and the most promising among them was:
Do you know of someone in your community who is sick with a fever, along with cough, shortness of breath, or difficulty breathing right now?
We decided to deploy this proxy question1 on April 11, 2020. We narrowed our focus to fewer counties: roughly the top 600 in terms of population, and estimated the daily % CLI-in-community, the percentage of people who know someone in their community with COVID-like illness. The initial results far exceeded our expectations, and were promising enough that within days we added this CLI-in-community question to our survey through Facebook.
To give you a feel for the data, below we plot the daily new COVID-19 cases per 100,000 people versus the estimated % CLI-in-community from our Google survey, at the state level, averaged over April 11 to mid-May. This is shown on the left, and on the right, we reproduce this with the estimated % CLI-in-community from our Facebook survey.
library(covidcast)
library(dplyr)
library(ggplot2)
library(gridExtra)
# Fetch county-level Google and Facebook % CLI-in-community signals, and JHU
# confirmed case incidence proportion
df_go = covidcast_signal("google-survey", "smoothed_cli", geo_type = "state")
start_day = min(df_go$time_value)
end_day = max(df_go$time_value)
df_fb = covidcast_signal("fb-survey", "smoothed_hh_cmnty_cli",
start_day, end_day, geo_type = "state")
df_in = covidcast_signal("jhu-csse", "confirmed_7dav_incidence_prop",
start_day, end_day, geo_type = "state")
# Join by state, average signals, compute correlations
df1 = inner_join(df_go %>% group_by(geo_value) %>% summarize(x = mean(value)),
df_in %>% group_by(geo_value) %>% summarize(y = mean(value)),
by = "geo_value")
df2 = inner_join(df_fb %>% group_by(geo_value) %>% summarize(x = mean(value)),
df_in %>% group_by(geo_value) %>% summarize(y = mean(value)),
by = "geo_value")
# Join again to get state populations
df1 = inner_join(df1, state_census %>% mutate(ABBR = tolower(ABBR)),
by = c("geo_value" = "ABBR"))
df2 = inner_join(df2, state_census %>% mutate(ABBR = tolower(ABBR)),
by = c("geo_value" = "ABBR"))
# Red, blue (similar to ggplot defaults), then yellow
ggplot_colors = c("#FC4E07", "#00AFBB", "#E7B800")
# Now make plots
subtitle = paste("Averaged over", start_day, "to", end_day)
p1 = ggplot(df1, aes(x = x, y = y, label = toupper(geo_value))) +
geom_smooth(method = "lm", col = ggplot_colors[2], se = FALSE) +
geom_point(aes(size = POPESTIMATE2019), color = ggplot_colors[2],
alpha = 0.5) +
scale_size(name = "Population", range = c(1, 10)) +
geom_text(alpha = 0.5) +
labs(x = "% CLI-in-community from Google surveys",
y = "Daily new confirmed COVID-19 cases per 100,000 people",
title = "COVID-19 case rates vs Google % CLI-in-community",
subtitle = subtitle) +
theme_bw() + theme(legend.position = "bottom")
p2 = ggplot(df2, aes(x = x, y = y, label = toupper(geo_value))) +
geom_smooth(method = "lm", col = ggplot_colors[1], se = FALSE) +
geom_point(aes(size = POPESTIMATE2019), color = ggplot_colors[1],
alpha = 0.5) +
scale_size(name = "Population", range = c(1, 10)) +
geom_text(alpha = 0.5) +
labs(x = "% CLI-in-community from Facebook surveys", y = "",
title = "COVID-19 case rates vs Facebook % CLI-in-community",
subtitle = subtitle) +
theme_bw() + theme(legend.position = "bottom")
grid.arrange(p1, p2, nrow = 1)
In both plots, we see a reassuring trend, but the trend on the left is noticeably stronger. Indeed, the correlation here between the Google signal and case rates is 0.84, while that between the Facebook signal and case rates is 0.64. To be fair, we should note that the Google signal comprises a much larger number of survey samples (as we’ll emphasize next), and the Facebook signal’s correlations to case rates shot up in mid-June (as we saw last time and we’ll revisit, shortly).
From April 11 through May 14, we ran Google surveys in over 600 counties per day, with a target of at least 1,000 responses per county. The average number of responses per day was over 600,000, and at its peak, over 1.2 million! (By comparison, our survey through Facebook averages about 74,000 responses per day.) The actual sampling scheme behind our Google survey is more complicated, and involves two-level stratification, across both counties and states. For details, including those on statistical estimation, visit our {{< apireflink "api/covidcast-signals/google-survey.html" "COVIDcast signals documentation" >}}. On May 15, we paused our Google survey to focus on our Facebook survey, which is both longer and more complex. Importantly, the latter is not a replacement for the former, and our two surveys have different and complementary use cases.
We discuss some similarities and differences between the Google and Facebook surveys. Starting with similarities, both have been deployed at a massive scale, reaching tens of thousands of people per day, and covering much of the US at the county level. To state the obvious, both ask the same question: whether a person knows someone in their community with COVID-like illness, and both lead to an estimate of % CLI-in-community.
Below we assess the numerical similarity of these estimates via correlations: we correlate them against each other, and for reference, correlate each against COVID-19 case rates. To be more specific, for each pair of the following: Google signal, Facebook signal, and COVID-19 case rates, and for each day that we have data available, we compute the Spearman correlation across all counties that had at least 200 cumulative COVID-19 cases by May 14 (the end of Google survey data). Over the first month of data, from mid-April to mid-May, we can see that the highest correlations clearly belong to those between the two survey signals. This is as expected, since in principle, these two surveys are measuring the same underlying quantity.2 The next largest correlations over the first month belong to those between the Google signal and case rates, which for the most part holds a substantial gap over the correlations between the Facebook signal and case rates. This is no doubt encouraging, especially because we’d hope that the Google correlations would have only improved later in the year (as did the Facebook correlations, which we {{< reflink "2020-08-26-fb-survey#basic-correlation-analysis" "previously suggested" >}} could have been due to the increase in the diversity of county-level case rates around mid-June).
# Fetch county-level Google and Facebook % CLI-in-community signals, and JHU
# confirmed case incidence proportion
df_go = covidcast_signal("google-survey", "smoothed_cli")
start_day = min(df_go$time_value)
end_day = "2020-09-01"
df_fb = covidcast_signal("fb-survey", "smoothed_hh_cmnty_cli",
start_day, end_day)
df_in = covidcast_signal("jhu-csse", "confirmed_7dav_incidence_prop",
start_day, end_day)
# Consider only counties with at least 200 cumulative cases by Google's end
case_num = 200
geo_values = covidcast_signal("jhu-csse", "confirmed_cumulative_num",
max(df_go$time_value), max(df_go$time_value)) %>%
filter(value >= case_num) %>% pull(geo_value)
df_go_act = df_go %>% filter(geo_value %in% geo_values)
df_fb_act = df_fb %>% filter(geo_value %in% geo_values)
df_in_act = df_in %>% filter(geo_value %in% geo_values)
# Compute correlations, per time, over all counties
df_cor1 = covidcast_cor(df_go_act, df_in_act, by = "time_value",
method = "spearman")
df_cor2 = covidcast_cor(df_fb_act, df_in_act, by = "time_value",
method = "spearman")
df_cor3 = covidcast_cor(df_go_act, df_fb_act, by = "time_value",
method = "spearman")
# Stack rowwise into one data frame, then plot time series
df_cor = rbind(df_cor1, df_cor2, df_cor3)
df_cor$what = c(rep("Google and case rates", nrow(df_cor1)),
rep("Facebook and case rates", nrow(df_cor2)),
rep("Google and Facebook", nrow(df_cor3)))
ggplot(df_cor, aes(x = time_value, y = value)) +
geom_line(aes(color = what)) +
scale_color_manual(values = ggplot_colors) +
labs(title = "Correlation between survey signals and case rates",
subtitle = sprintf("Over all counties with at least %i cumulative cases",
case_num),
x = "Date", y = "Correlation") +
theme_bw() + theme(legend.pos = "bottom", legend.title = element_blank())
Now let’s consider the differences between the surveys. Here’s a summary:
Our Facebook survey is advertised by Facebook but run by us (on a CMU-licensed Qualtrics platform); this means that we receive all the individual survey responses directly (and Facebook never sees any of the data).
On the other hand, our Google survey is deployed directly by Google through partner websites and apps they use to run questionnaires; this means that we don’t see individual survey responses, but receive aggregated survey data from Google.
This makes a big difference as to how much (and what questions) we can ask on the survey: our Google survey is just a single question long, and our Facebook survey is much longer and more detailed, currently over 35 questions.
Finally, there’s a big difference in how much we control with respect to the geographic distribution of the survey samples: on our Facebook survey, we have no control over this, but on our Google survey we have full control, in that we can pick the counties we want to sample from ahead of time.
As we can see from the above summary, the two survey schemes are complementary, and could be used synergistically. Our Facebook survey is a continuously-running, wide-reaching instrument that provides answers to a {{< apireflink "symptom-survey/coding.html" "rich set of questions" >}} (beyond COVID-related symptoms, it asks about contacts, risk factors, behavior, and demographics). When we find something interesting that warrants follow-up and/or generalization to unseen locations, we could then deploy our Google survey in select counties—using it like a survey microscope (credit to Hal Varian for inventing the terminology!). This could be done automatically (it would be a pretty big, nonstationary multi-armed bandit problem) or manually (in collaboration with partners in public health and/or data journalists). Stay tuned to the Delphi blog for updates.
In the survey methodology literature, a “proxy question” is one in which the subject is asked to report on someone else. The traditional view seems to be that proxy questions can undermine survey data quality, but in our setting it’s critical: not only does it provide a safeguard against revealing personal health information, it turned out to deliver {{< reflink "2020-08-26-fb-survey#basic-correlation-analysis" "much higher correlations" >}} with case rates than the direct (non-proxy) question.↩
A closer look reveals that the relationship between the Google % CLI-in-community and Facebook % CLI-in-community signals is not 1:1. For example, you can check the x-axes in the first example in this blog post: the range of the Facebook signal is over twice that of the Google signal. There are differences in the setups we can point to: the two surveys phrase the CLI-in-community question slightly differently; they reach different subpopulations of the US; and the estimation procedures behind the surveys handle missing responses differently. But as far as we can tell, none of this can really explain why the Facebook numbers are over twice as large as the Google ones, a trend that seems pretty consistent across location and time. We’ll save rigorous analysis for when we work on deploying these two surveys in tandem; for now, we emphasize that this observation reiterates the importance of focusing on time-varying trends in the survey signals, not the signal values themselves (a point we {{< reflink "2020-08-26-fb-survey#why-run-these-surveys" "made in our last post" >}}). Here, the self-reporting aspect must somehow be creating greatly different levels of bias in the two surveys; in an absolute sense, the subsequent estimates of % CLI-in-community strongly disagree, so both can’t be right, and this casts doubt on the idea that either could be bias-free.↩


Label Heading
1
Bar chart d3 implementation
Read the full post
here
Simple Bar Chart - One variable
Bar Chart - Two variables
Bar Chart - Three variables
Bar Chart - Stacked


Sultan
Command and Rule over your Shell
NOTE 1: Sultan only supports Python 2.7.x
.
NOTE 2: Your input is welcome! Please provide your feedback by creating issues on Github.
What is Sultan?
Sultan is an interface to Bash from Python. Shell commands get to the point of what you want them to do. For example,
sudo yum install tree
would install tree
on your local machine. However, we normally access command
line utilities like yum
, via bash, and Bash is just not as nice as Python.
Python's beautiful syntax make code readable and easy to maintain far more than
Bash.
Bash is great for small scripts, but when we get complex scripts, Bash just gets very tough to use. This is why Sultan was created.
Basic Usage
Sultan allows you to run bash commands from inside Python using simple function calls. Here is a quick example to install tree via Sultan.
from sultan.api import Sultan
def install_tree():
s = Sultan()
s.sudo("yum install -y tree").run()
Here is the output:
sudo yum install -y tree;
Loaded plugins: fastestmirror, langpacks
Loading mirror speeds from cached hostfile
* epel: ca.mirror.babylon.network
* nux-dextop: mirror.li.nux.ro
Resolving Dependencies
--> Running transaction check
---> Package tree.x86_64 0:1.6.0-10.el7 will be installed
--> Finished Dependency Resolution
Dependencies Resolved
================================================================================
Package Arch Version Repository Size
================================================================================
Installing:
tree x86_64 1.6.0-10.el7 CentOS-7-Base 46 k
Transaction Summary
================================================================================
Install 1 Package
Total download size: 46 k
Installed size: 87 k
Downloading packages:
Running transaction check
Running transaction test
Transaction test succeeded
Running transaction
Installing : tree-1.6.0-10.el7.x86_64 1/1
Verifying : tree-1.6.0-10.el7.x86_64 1/1
Installed:
tree.x86_64 0:1.6.0-10.el7
Complete!
Advanced Usage
The following are advanced usage of Sultan:
Pipe
In bash, we'd like to pipe multiple commands to take the output of the first
command and send it to the second command. For example, suppose we want to
find all the files that contain the word Sultan
in a bunch of files in a
given directory. We would do this:
find ~/projects/sultan -name "*.py" | xargs grep "Sultan"
We would do the following with Sultan:
s = Sultan()
response = s.find("~/projects/sultan -name '*.py'").pipe().grep("Sultan").run()
And
In bash, we'd like to run two commands together, like changing to a directory and running a command there, like:
cd /tmp/ && ls -lah
We would do the following with Sultan:
s = Sultan()
response = s.cd("/tmp").and_().ls("-lah")
Redirect
In bash, something we do a lot is redirect output (stdout
, stderr
) into a
file. We would do it like this:
find / -type d > /tmp/contents
We would do the following with Sultan:
s = Sultan()
response = s.find("/ -type d").redirect("/tmp/contents", stdout=True)
Custom commands
Sultan still needs a lot of work and we understand that. We encourage you to create bug reports and feature requests on the Github page at: https://github.com/aeroxis/sultan/issues
That being said, if you want to do something custom, run:
s = Sultan()
s.command = "yum install -y gcc"
response = s.run()


Before Change
// Spin up Docker contain and extract custom feats
cmd = ["docker", "run",
"-v", "%s:/home/mltsp" % cfg.PROJECT_PATH,
"--name=%s" % container_name,
"mltsp/extract_custom_feats"]
process = Popen(cmd, stdout=PIPE, stderr=PIPE)
// Grab outputs
stdout, stderr = process.communicate()
if str(stderr).strip() != "" and stderr != b"":
print("\n\ndocker container stderr:\n\n", str(stderr).strip(), "\n\n")
After Change
ridc.docker_copy(client, cont_id, "/tmp/results_list_of_dict.pkl",
target=path_to_tmp_dir)
print("/tmp/results_list_of_dict.pkl copied to host machine.")
// Load pickled results data
with open(os.path.join(path_to_tmp_dir, "results_list_of_dict.pkl"),
"rb") as f:
results_list_of_dict = pickle.load(f)


There's something wrong with your base code and Franklin could't build it. Please check and push code to continue.
Building...
[[environment.build.deployed | date:'MM-dd-yyyy HH:mm']]
Ready
Error
Deployed
Deploying...
Auto Deploys


Note: The Projects API is currently available for
developers to preview. During the preview period, the API may change without
advance notice. Please see the
blog post for full
details. To access the API during the preview period, you must provide a
custom media type in the Accept
header:
application/vnd.github.inertia-preview+json
Warning: The API may change without advance notice during the preview period. Preview features are not supported for production use. If you experience any issues, contact GitHub Support or GitHub Premium Support.
POST /projects/columns/:column_id/cards
Note: GitHub's REST API v3 considers every pull
request an issue, but not every issue is a pull request. For this reason,
"Issues" endpoints may return both issues and pull requests in the
response. You can identify pull requests by the
pull_request
key.
Be aware that the id
of a pull request returned from
"Issues" endpoints will be an issue id. To find out the
pull request id, use the "List pull requests" endpoint.
| Name | Type | Description |
|---|---|---|
note |
string |
The card's note content. Only valid for cards without another type
of content, so you must omit when specifying
content_id and content_type .
|
content_id |
integer |
The issue or pull request id you want to associate with this card. You
can use the
List repository issues
and
List pull requests endpoints
to find this id. Note: Depending on whether you use the issue id or pull request id, you will need to specify Issue or PullRequest as the
content_type .
|
content_type |
string |
Required if you provide content_id . The type of content you want to associate with this card. Use
Issue when content_id is an issue id and use
PullRequest when content_id is a pull request
id.
|
Status: 201 Created
{
"url": "https://api.github.com/projects/columns/cards/1478",
"id": 1478,
"node_id": "MDExOlByb2plY3RDYXJkMTQ3OA==",
"note": "Add payload for delete Project column",
"creator": {
"login": "octocat",
"id": 1,
"node_id": "MDQ6VXNlcjE=",
"avatar_url": "https://github.com/images/error/octocat_happy.gif",
"gravatar_id": "",
"url": "https://api.github.com/users/octocat",
"html_url": "https://github.com/octocat",
"followers_url": "https://api.github.com/users/octocat/followers",
"following_url": "https://api.github.com/users/octocat/following{/other_user}",
"gists_url": "https://api.github.com/users/octocat/gists{/gist_id}",
"starred_url": "https://api.github.com/users/octocat/starred{/owner}{/repo}",
"subscriptions_url": "https://api.github.com/users/octocat/subscriptions",
"organizations_url": "https://api.github.com/users/octocat/orgs",
"repos_url": "https://api.github.com/users/octocat/repos",
"events_url": "https://api.github.com/users/octocat/events{/privacy}",
"received_events_url": "https://api.github.com/users/octocat/received_events",
"type": "User",
"site_admin": false
},
"created_at": "2016-09-05T14:21:06Z",
"updated_at": "2016-09-05T14:20:22Z",
"archived": false,
"column_url": "https://api.github.com/projects/columns/367",
"content_url": "https://api.github.com/repos/api-playground/projects-test/issues/3",
"project_url": "https://api.github.com/projects/120"
}


Dozens of Firebombs Found Hidden in Galilee Cemetery
by Hana Levi JulianDozens of ready-to-use firebombs (Molotov cocktails) were found this weekend hidden in a Christian cemetery in the Galilee Arab village of Tur’an.
A total of 34 of the firebombs were discovered, all of them primed and ready for use.
It’s not clear who stockpiled them in the cemetery. An investigation is underway.


The AngularJS library has a date filter that allows JavaScript Date objects to be displayed using a provided format. This is an awesome feature, and it's great that you can use it anywhere, including text input boxes. But the problem is that it only works one-way. There's currently no way to convert strings back into Date objects while using the same format initially used to display it. This parser was designed to overcome this problem.
This is a basic example demonstrating how the parser can convert manually entered date strings into JavaScript Date objects.
Selected date: {{date | date:'MMM d, y h:mm a'}}
<input type="text" ng-model="date" date-parser="dd.MM.yyyy HH:mm" />
The AngularJS date filter comes with several shortname formats that you can use. The DateParser can recognise these formats and will convert the date strings accordingly.
Selected date: {{date | date:'MMM d, y h:mm a'}}
<input type="text" ng-model="date" date-parser="medium" /> <input type="text" ng-model="date" date-parser="short" /> <input type="text" ng-model="date" date-parser="fullDate" /> <input type="text" ng-model="date" date-parser="longDate" /> <input type="text" ng-model="date" date-parser="mediumDate" /> <input type="text" ng-model="date" date-parser="shortDate" /> <input type="text" ng-model="date" date-parser="mediumTime" /> <input type="text" ng-model="date" date-parser="shortTime" />
Date string formats can be changed on-the-fly and associated views will automatically be updated to use the new format.
Selected date: {{date | date:'MMM d, y h:mm a'}}
<input type="text" ng-model="date" date-parser="{{format}}" />
The parser also allows you to change the timezone. However, bear in mind that the model will still contain the date and time for the local timezone, minus the offset.
Selected date: {{date | date:'MMM d, y h:mm a Z'}}
<input type="text" ng-model="date" date-parser="dd/MM/yyyy HH:mm Z" />


First name
Surname
E-Mail*
Password*
Repeat Password*
Register
×
Register error
The following problems occurs : {{vm.text}}


The Fluid.Dissipation library provides convective heat transfer and pressure loss (HTPL) correlations for a broad range of energy devices to build up thermohydraulic energy systems.
This section introduces an implementation method for the
integration of the provided HTPL functions by Fluid.Dissipation
into own application models. Additionally you can find ready-to-use
application models integrated into Modelica.Fluid as
thermohydraulic framework (see package
Fittings).
In the following the implementation method is described in 5 steps
for a straight pipe as example. Generally the implementation method
can be used for all HTPL correlations throughout the library in the
same manner.
All thermohydraulic systems using pressure loss calculations can be modelled for an incompressible case , where the pressure loss (DP) is calculated in dependence of a known mass flow rate (m_flow)
DP = f(m_flow,...)
or a compressible case , where the mass flow rate (M_FLOW) is calculated in dependence of a known pressure loss (dp)
M_FLOW = f(dp,...).
In both cases one target variable (DP for the compressible or M_FLOW for the incompressible case) is calculated as a function of the corresponding input variable (m_flow or dp respectively). Both functions for these cases can be found in the library for the pressure loss device of interest enlarged with a corresponding underscore describing its intended use (functionname_MFLOW for compressible or functionname_DP for incompressible calculation).
To create a simplified thermohydraulic model, the pressure loss (dp) and the mass flow rate (M_FLOW) have to be defined as unknown variables and only a functional correlation between them is still missing. Here the implementation for the compressible case of a flow model will be explained as example.
model straightPipe //compressible case M_FLOW = f(dp) Modelica.SIunits.Pressure dp "Input pressure loss"; Modelica.SIunits.MassFlowRate M_FLOW "Output mass flow rate"; end straightPipe equation end straightPipe
The HTPL correlations are modelled with functions for several devices. The pressure loss of a straight pipe to be modelled can be found by browsing through the Fluid.Dissipation library and looking up the function of interest, here:
Fluid.Dissipation.PressureLoss.StraightPipe.dp_overall_MFLOW
This HTPL correlation for the compressible case of a straight pipe have to be dragged and dropped in the equation section of the equation layer of the model in Step 1.
model straightPipe //compressible case M_FLOW = f(dp) Modelica.SIunits.Pressure dp "Input pressure loss"; Modelica.SIunits.MassFlowRate M_FLOW "Output mass flow rate"; equation Fluid.Dissipation.PressureLoss.StraightPipe.dp_overall_MFLOW end straightPipe
The chosen function in Step 2 still needs its corresponding input values provided by records. These input records are split into one for input parameters (e.g., for geometry) and one for input variables (e.g., for fluid properties). The name of these input records are identical with the corresponding function but with the extension _IN_con for parameters and _IN_var for variables as input. These corresponding input record for the chosen function have to be dragged and dropped on the diagram layer of the model in Step 1.
Input parameter record: Fluid.Dissipation.PressureLoss.StraightPipe.dp_overall_IN_con IN_con Input variable record: Fluid.Dissipation.PressureLoss.StraightPipe.dp_overall_IN_var IN_var
Now the equation layer of the model in Step 1 should look similar to the following (without comments and annotation):
model straightPipe ... //records Fluid.Dissipation.PressureLoss.StraightPipe.dp_overall_IN_con IN_con; Fluid.Dissipation.PressureLoss.StraightPipe.dp_overall_IN_var IN_var; equation Fluid.Dissipation.PressureLoss.StraightPipe.dp_overall_MFLOW end straightPipe
Now the input record have to be assigned to the chosen function in the equation layer. The resulting function-record implementation for the compressible case looks like the following:
model straightPipe ... equation //compressible case M_FLOW = Fluid.Dissipation.PressureLoss.StraightPipe.dp_overall_MFLOW(IN_con,IN_var,dp); end straightPipe
Here the compressible case for the unknown mass flow rate (M_FLOW) is calculated by the known pressure difference (dp) out of the interfaces of the thermohydraulic framework and the input records (IN_con,IN_var) provide data like geometry and fluid properties for example.
In the last step the variables of the input records for the function have to be assigned. The assignment of the record variables can either be done directly in the record on the diagram layer or in the equation layer. The assignment of the input record in the equation layer results into the following model:
model straightPipe ... //compressible fluid flow //input record Fluid.Dissipation.Examples.Applications.PressureLoss.BaseClasses.StraightPipe.Overall.Pres sureLossInput_con IN_con( d_hyd=d_hyd, L=L, roughness=roughness, K=K); Fluid.Dissipation.Examples.Applications.PressureLoss.BaseClasses.StraightPipe.Overall.Pres sureLossInput_var IN_var( eta=eta, rho=rho); ... end straight Pipe;
If the implementation of a HTPL correlation is done in an existing application model, the unknown variables out of Step 1 (M_FLOW and dp for compressible or DP and m_flow for incompressible case) have to be adjusted to the model variables (typically the interface variables). The implementation of HTPL correlation into Modelica.Fluid can be found for flow models of several devices.


Hello, world!
Some More!
Check it out.
Another one this one with Blue. Should be Blue! Don't be so Blue! .........-----


Babelfish is an enterprise translation "micro service" web app, built upon an HTTP REST web API, allowing you to easily meet most of your enterprise translation needs.


br is inline while p is block, block adds an invisble box around the text.
- Div is block container that adds a box around the enclosed content.
Structure of HTML Document
title
Start with document type, header is where a link to CSS or JS code is inserted.
Most of the content is in the body of the HTML.


false positive etc.
false positive（FP）: indicates presence of a condition when in reality it is not present - 误诊为有病
false negative（FN）: indicates no presence of a condition (the result is negative), when in reality it is present - 误诊为无病
true positive（TP）: 正确的判定为有病
true negative（TN）: 正确的判定为无病
mAP
IoU
Intersection over Union is a ratio between the intersection and the union of the predicted boxes and the ground truth boxes.
Precision and Recall
$$Precision = \frac{TP}{(TP+FP)}$$
$$Recall = \frac{TP}{(TP+FN)}$$
mAP
The AP (average precision) is defined as the mean of the Precision values at these chosen N Recall values.
The mAP hence is the Mean of all the Average Precision values across all your classes
reference: towards data science
ILSVRC-top-N-error
Local response normalization
implements some kind of lateral inhibition inspired by real neurons; see alexnet section 3.3 for details.
explaination
spatial pyramid pooling
provide fixed-sized flattened vector to fully connected convolutional layer inspired by Bag of Words (BoW) to adapt not fixed-sized images, normally fixed-sized images are fed into CNN by resizing method such as crop, or warp.
batch normalization
normalizing layers' input over mini-batch to solve problem of covariate shift (sample distribution difference between mini-batchs) and internal covariate shift (distribution difference between hiden layers's inputs) .
explaination


Office Killer (1997)
Seen on 23 December 1997 for $8 at the Quad Cinema.
The worst-kept secret in my office is my *necrology*--a list of everyone who has left the premises during my tenure of 3+ years. Publishing has its victims and there is often lots of turnover. In *Office Killer*, Dorine Douglas (Carol Kane) keeps a very different, more accurate necrology, one created at her own hand. Indeed, her basement becomes a mortuary, filling up with her victims--people at work who would have gladly seen her downsized out of her copy editing job.
Norah Reed (Jeanne Tripplehorn) is brought in to bring the magazine--*Constant Consumer*--kicking and screaming into the 21st Century. This means making jobs part-time and sending people to work at home. Dorine, a mousy, unfashionable nervous wreck with a nearly robotic voice and nervous mannerisms, is practically a nonentity. Ignored and disliked by those who don't know her, she is chosen to be made part-time and work at home via laptop, even though she knows more than most of the young ne'er-do-wells at work. People often misspell her name, or even call her my the wrong name. After her accidental electrocution of the lecherous writer Gary (David Thornton), Dorine decides to bring his corpse home, and then adds to her macabre doll collection with premeditated murder.
A consequence of Dorine's murders is that she dresses better and her worth becomes more apparent to her editors and to Norah the "efficiency expert"--despite the fervent protests of the young layabout Kim (Molly Ringwald). What Dorine's co-workers discover, only when it's too late, is that Dorine is very smart, and uses what she learns by just peeking over their shoulders against them.
The biggest problem with *Office Killer* is that it gets very grisly.  Dorine's murders are also extended to non-officemates; there is even a corpse down there in the end that we never even see killed. Dorine also dismembers some of the victims, attaching the fingers to the hands of her kitchen clock. It gets a lot less tongue-in-cheek as it goes on.
*Office Killer* offers a certain amount of elegance on a low budget. The screen credits slither over items you would find in an office by merely projecting them via slides. The music by Evan Lurie is low-key but very intense and sustains the film's edgy mood. Also, director Cindy Sherman is able to manage some wonderfully stifling shots from exteriors, caging her characters by framing them in windows or fire escape terraces and brick walls. The offices are drab and ill-lit, adding to the macabre mood of the film.
At one point, before Dorine has mastered the laptop, Danny (Michael Imperioli) tells her that some people like working from home so much, they "hate to talk to people" after a while, as if Dorine's most valuable to the magazine if she is never actually seen. When Dorine kills people, the office staff notices they are gone, but the police are never actually called it. It's as if it's more annoying to have inconvenienced the work routine, never mind that someone might actually be in trouble. *Office Killer* makes a nice counterpart to *Denise Calls Up*, another movie in which the reduction of personal contact thanks to technology is explored.
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


Earthquake Damage Prediction
During Fall 2020, I took a course on Machine Learning and Data Analysis (CS4641 at Georgia Tech). As part of the course, my team and I were required to complete a final project which involved us picking a dataset, exploring and preprocessing it, and experimenting on it with the different algorithms that we had learnt. This is an overview of the process we followed and the results we obtained.
Here is the Competition/Dataset Information!
Introduction and Background
Within the United States alone, earthquakes destroy nearly $4.4B of economic value yearly. Our team will be delving into the 2015 Nepal Earthquake Open Data Portal. This data, which was collected using mobile devices following the Gorkha Earthquake of April 2015, details the level of destruction brought upon more than 200,000 buildings in the area. By utilizing various features reported by Nepali citizens (such as building size, purpose, and construction material), we will construct a machine learning classifier capable of determining the extent to which a building would be damaged. We will also run unsupervised clustering algorithms to search for features that best represent the damage classifications. This project, combined with technologies such as the CV-based city scanners following earthquakes (Ji, 2018) will ultimately provide a better understanding of susceptibility to earthquake-induced damage, valuable information that can be leveraged by city planners.
Planning
This project will be divided into two parts:
- Data Preprocessing and Visualization
- Model Selection, Training, and Evaluation
The data has been collected for us, but we plan to spend a significant amount of time preparing (cleaning, encoding, etc) the data for the model. We will also perform meaningful visualizations to better understand the relationships between our features. The classifier will be trained using supervised learning algorithms such as Support Vector Regressors (Asim, 2018), Logistic Regression, and Hybrid Neural Networks (Asim, 2018) and unsupervised learning algorithms such as KMeans clustering. The hyperparameters will be tuned using the GridSearchCV process. The model performances will be compared using our test set and the one that generalizes the best will be chosen.
Expected Results
Using supervised machine learning algorithms we hope to identify which factors affect the level of damage to a building from an earthquake. We’ll compare each of the results by micro averaged F1 score, which will balance precision and recall modified to gauge accuracy for classification into 3 categories (DrivenData). We can also use dimensionality reduction to reduce the number of features from 38 to a more manageable amount by seeing which features are correlated to each other.
Data Exploration and Preprocessing
Our initial approach was to scan for data imbalance, search for NaN values, and visualize the distributions of various features as well as the degree to which they correlation with the value we were trying to predict (damage grade).
Upon initial visualization, it becomes clear that this isn’t a very highly predictive dataset. At most, the correlation of any given variable is +/- 0.2. In other words, it will likely be difficult to accurately classify the damage grades
In the initial data, we were also given a few categorical variables. These included land condition, roof type, floor type, legal status, and more. We used one-hot encoding to allow for models to be trained on this non-integer data. Fortunately, this data did not have any null values, so imputation was not necessary.
In terms of the data balance, the data is roughly imbalanced towards damage grade 2. However, it is not severe enough to have to add any special sampling techniques for the minority classes (in this case, damage 1).
Of the 38-feature dataset, 8 of the features were categorical. One-hot encoding was used to transform these categorical features into various binary featuresm prior to training any models.
Experiments with Models
The data has been collected for us, but we plan to spend a significant amount of time preparing (cleaning, encoding, etc) the data for the model. We will also perform meaningful visualizations to better understand the relationships between our features. The classifier will be trained using supervised learning algorithms such as Support Vector Regressors (Asim, 2018), Logistic Regression, and Hybrid Neural Networks (Asim, 2018) and unsupervised learning algorithms such as KMeans clustering. The hyperparameters will be tuned using the GridSearchCV process. The model performances will be compared using our test set and the one that generalizes t he best will be chosen.
- Kmeans
- DBSCAN
- PCA
- LDA
- Cross validation
- Hybrid/Deep Neural Networks
- AutoML
- Decision Tree
- Random Forest Decision Tree
- XGBoost Decision Tree
- LightGBM
Dimensionality Reduction
At the end of our preprocessing step, we were left with a total of 71 features after categorical encoding. It was not ideal for us to feed this into the classifiers and neural net architectures that we had constructed as it was entirely possible for us to capture the variability and patterns in the data with fewer features. Thus, we decided to try some dimensionality reduction techniques to perform effective feature selection.
We began with Principal Component Analysis. It uses SVD to produce a set of vectors known as the principal components, with the objective of capturing the maximum variability in the data with the fewest number of features.
The results of PCA in 2 dimensions is shown below
It is quite clear that there isn’t a discernable boundary between the principal components. The situation does not improve much when visualized in 3 dimensions:
Thus, PCA did not prove to be effective with our dataset. We thus resorted to another method: Linear Discriminant Analysis. It simply attempts to express a linear dependence relationship between the features in order to root out features with no additional novel information. The results of LDA on the dataset are shown below:
Similar to PCA, there is no discernable clusters produced by LDA. To summarize, dimensionality reduction proved to be of no use to us in terms of feature selection. We thus decided to move forward by maintaining all features in the dataset.
DBSCAN and K-Means Clustering
We tried DBSCAN, but with the high dimensionality of the data (39 features with one-hot encoding) it was very difficult to get greater than 0 clusters unless the epsilon parameter was very high. In order to achieve some clusters the epsilon value had to be greater than 40 even with just a minpts of 3. Anything below that epsilon would result in 0 clusters. After trying some more variants of eps, a trial using an eps of 42, minpts of 3 and euclidian distance as the metric, we were able to get 3 clusters
Tried KMEANS while setting the number of n_clusters to 3 in hopes of clustering them close to damage grade. Just like with DBSCAN it seems KMEANS clustering does not perform well either with high dimensional data. KMEANS was able to provide an output of each datapoint to one of 3 clusters but after comparing all variations of cluster assignments to damage grade, the maximum accuracy we got was 33.5%.
Neural Networks (using SKLearn and Keras)
One of the primary reasons for resorting to neural networks was due to the shear number of features to consider in the dataset. They have proven to effectively capture complex non-linear hypothesis with high accuracy.
We began with the Multilayer Perceptron algorithm, which resulted it in an accuracy of 51.2%. Naturally, we tried adding more hidden layers using Keras in an effort to capture nuances in the dataset. Our accuracy was topped off at 56.89%. We used the following hyperparameters for the NN:
- Optimizer: Stochastic Gradient Descent (SGD)
- Loss: Categorical Cross-Entropy
- Nestorov Momentum with a value of 0.9
From the results, it was clear that the ANN was unable to improve its classification accuracy beyond 56.89%.
AutoML
AutoML was utilized as a benchmark test to see if Microsoft Azure’s “Automatic ML” classification would prove effective. One simply uploads the data, specifies the type of task they are seeking to perform (classification, in our case), and then Azure runs various ML algorithms on it with the purpose of optimizing performance. The results were equally poor with a lot of our previous testing, as visualized below.
Decision Trees
There were 4 different types of decision trees that were evaluated including normal decision trees, random forest, extreme gradient boosting, and lite gradient boosting. Using the one-hot encoded data to convert categorical data into numerical data and 5-fold cross validation, a small version of each type of tree was created to compare their effectiveness by the F1 score metric.
The results from the initial F1 score comparison demonstrate that random forest, extreme gradient boosting, and lite gradient boosting are more promising than the normal decision tree. The normal decision tree had already started overfitting the data since its train accuracy is significantly higher than its validation accuracy. Due to this overfitting, normal decision trees were not explored farther.
Random Forest
Random forest decision trees reduce the variance in decision trees since they specify random feature subsets and build and combine many small trees. To make a prediction, random forest trees will either take the prediciton with the highest probability or average the predictions made by its smaller trees. By increasing the number of trees in the forest, both the training and validation accuracy increase due to the smaller tree averages converging on the true trends in the data. This is the idea of ensemble learning which is revisited later in the decision tree exploration.
Extreme Gradient Boosting
Extreme gradient boosting also is composed of a set of decision trees but is built by training a tree to add to the forest. Instead of using an average or max of the probabilities from its trees while making predictions, extreme gradient boosting combines the tree prediciton results sequentially (Glen). Increasing the number of trees in the forest also improves the accuracy.
Lite Gradient Boosting
Lite gradient boosting is also a gradient boosting framework, however it builds its trees by adding to leaves instead of adding levels.
This architecture is highly dependent on the number of leaves it expands. More leaves allow it to fit data better, but also can cause overfitting. This architecture can also be used with ensemble learning, and adding more trees will increase the accuracy. The results from the baseline accuracy tree test indicate that the tree should be made to fit the training data better since the train and validation accuracies were very similar. A comparison of the F1 score validation accuracies with varying the number of leaves is shown below.
The comparison of number of leaves above reveals that the optimal number of trees is 80. While evaluating the optimal number of trees, the F1 score constantly increases with diminishing reward. However, as the number of trees increases, the training time increases. 3,000 was the final number of trees selected.
The overall results from tuning are shown in the plot below:
This plot shows that the lite gradient boosting was the best technique at the end of the tuning done in this analysis.
Competition Results
As a whole, our classification model performed better than expected. While we initially struggled with various common types of classification (KMeans, DBScan, PCA, LDA), we eventually found success in the form of an ensemble using the litegbm framework. The random forest decision tree demonstrated the advantage of ensembles. While trying extreme gradient boosting, we discovered lightGBM, a gradient boosting framework that builds trees by expanding leaves. This allowed the ensemble decision tree to converge faster and had better success after tuning the number of leaves expanded. The best results were a result of an ensemble of lightGBM trees. We submitted our Lite Gradient Boosting method to classify the instances on their test set, and received the following results:
Concluding Thoughts
This project can benefit architects, engineers, and city planners by using the classification model to extrapolate and predict types of buildings that are likely to suffer from earthquake damage. Buildings with attributes similar to those that were more damaged can be reinforced. Both the visualization and classification models can be used in conjunction with earthquake prediction research (Rouet-Leduc, 2017) to provide advance humanitarian aid so buildings can be reinforced to take significantly less damage.
References
Asim, K. M., Idris, A., Iqbal, T., & Martínez-Álvarez, F. (2018). Earthquake prediction model using support vector regressor and hybrid neural networks. Plos One, 13(7). doi: 10.1371/journal.pone.0199004
DrivenData. (n.d.). Richter’s Predictor: Modeling Earthquake Damage. Retrieved September 28, 2019, from https://www.drivendata.org/competitions/57/nepal-earthquake/page/136/
Glen, Stephanie. “Decision Tree vs Random Forest vs Gradient Boosting Machines: Explained Simply.” Data Science Central, 28 July 2019, www.datasciencecentral.com/profiles/blogs/decision-tree-vs-random-forest-vs-boosted-trees-explained.
Ji, M., Liu, L., & Buchroithner, M. (2018). Identifying Collapsed Buildings Using Post-Earthquake Satellite Imagery and Convolutional Neural Networks: A Case Study of the 2010 Haiti Earthquake. Remote Sensing, 10(11), 1689. https://doi.org/10.3390/rs10111689
Mandot, Pushkar. “What Is LightGBM, How to Implement It? How to Fine Tune the Parameters?” Medium, Medium, 1 Dec. 2018, medium.com/@pushkarmandot/https-medium-com-pushkarmandot-what-is-lightgbm-how-to-implement-it-how-to-fine-tune-the-parameters-60347819b7fc.
Rouet‐Leduc, B., Hulbert, C., Lubbers, N., Barros, K., Humphreys, C. J., & Johnson, P. A. ( 2017). Machine learning predicts laboratory earthquakes. Geophysical Research Letters, 44, 9276– 9282. https://doi.org/10.1002/2017GL074677


We support the expansion of consciouness to exo-planetary dimensions.
Our Mission
In the pursuit of its mission objectives in aeronautics and space exploration, National Aeronautics and Space Administration (NASA) continues pushing the boundaries of its own foundations. Often, new technologies are needed to either enhance current capabilities or enable future ones.
The Innovative Partnerships Program (IPP) provides the organizational structure for acquiring, maturing, infusing and commercial technology and capabilities for NASA's Mission Directorates, Programs and Projects through investments and partnerships with Industry, Academia, Government Agencies and National Laboratories. As one of NASA's Mission Support Offices, the IPP supports all Mission Directorates and has Program Offices at each of the NASA Centers. In addition to leveraged technology investments, dual-use technology-related partnerships, and technology solutions for NASA, IPP enables cost avoidance, and accelerates technology maturation.


CreateDialog()
Syntax
Result = CreateDialog(#Dialog)Description
Create a new uninitialized dialog. To initialize the dialog, use OpenXMLDialog().
Parameters
#Dialog A number to identify the new dialog. #PB_Any can be used to auto-generate this number.
Return value
Returns nonzero if the dialog was created successfully and zero if not. If #PB_Any was used as the #Dialog parameter, then the auto-generated number is returned in case of success.
See Also
OpenXMLDialog(), FreeDialog()
Supported OS
All


LNUG Organisational Breakdown
- Email<EMAIL_ADDRESS>- Twitter: @LNUGorg
If you are the owner of a task, please try and pair up on each task in case your are sick, on holiday or just need a break and ensure they are in attendance!
Maintainers
We are here to answer any questions you have, however we are specifically focused on speakers, sponsorship or event space.
Ian Crowther
Oli Evans
Registration
Jon Kelly
Website
Simon McManus
Maillist
Adam Davis
Olu Niyi-Awosusi
Video Recordings & YouTube
Johnny Bridges
UX & Design
Max Duluc (maxwellito)
Ben Byford
Andy Trevorah
Gitter
TBA
Instagram
TBA
Lanyard
TBA
Attending
Olu Niyi-Awosusi
Catering
Adam Davis


Up
Index of module types
B
Binary_process
[
Binary_session
]
A process which is parametrized by a binary session type.
I
IO
[
Binary_session
]
Abstract type which can perform monadic concurrent IO.


Years Later, Some Can't Tell Who's On Street Fighter II Turbo's Japanese Cartridge
by Brian AshcraftYou are looking at the cartridge art for Street Fighter II Turbo’s Japanese release. It’s not only different from the US version but more mysterious. Can you tell who is on the cover? Ryu? Chun-Li? Which character is it?
Twitter user Tekitouaki wrote that for years, he thought that Ryu was on the cover.
This tweet went viral in Japan and was even covered on major sites like IT Media and My Game News Flash. People replied, comparing eyebrows and writing that they were either “Team Chun-Li” or “Team Ryu.”
Former Capcom artist Akira Yasuda, who created so much iconic Street Fighter art, even chimed in, writing, “I’d say it’s Chun-Li.”
There is another version of the cartridge with Ryu, so yes, the one in question does show Chun-Li. And now you know!


When you work with us, you are part of a team of committed collaborators. All aspects of our software development process are intergrated, interactive and agile.
Our approach unifies design, development and product management to create exceptional products.
We start each project by understanding your business goals, the user's needs and the product requirements.
Then we help translate them into effective and elegant solutions.
Before we sign a contract or write a line of code our team will spend the necessary time needed to understand your product vision.
The outcome of this scoping session is a proposal or high-level statement of work.
Based on your requirements, we can provide a complete offering or just the pieces you need.
Our design practice offers a full range of services including brand strategy, interaction and visual design and user experience testing.
Throughout your project, our designers create and implement visual design and workflows, solicit user feedback and work with you to make sure what gets built is what is needed.
All engineers are fluent in the latest enterprise, mobile and web development technologies.
They collaborate with yout team to write and improve code on a daily basis, using proven practices such as test-driven development and pair programming.
Planning and development is iterative. Because we are constantly coding and testing, the products we build are always ready to go live
This iterative process allows for changes as business requirements evolve.
Dark
Mighty Ontario
Orange
Jim Carrey
Have a Good Day
Cool Interface
Burned Logo
Bailley Wonger


[gecode-users] Starting search from a solution
Luca Di Gaspero
l.digaspero at uniud.it
Mon Nov 19 21:17:27 CET 2012
Hi all,
I am currently facing this issue: for modeling a sort of VRP problem I have the need to find a solution and then perturb the problem to add a new decision variable (say a new customer to be visited). I would like to let the search engine explore the search space of the modified problem starting from the solution of the original problem, is there a way to implement this behavior?
I make a concrete example, suppose the nodes to be visited are initially {1, 2, 3}, the decision variables is the set succ of successors (succ[i] \in {1..3}, i = 1, …, 3) and the first solution satisfying also the other constraints is succ = [3, 1, 2].
Now I need to add a node 4, so the successors becomes succ[i] \in {1..4}, i =1, …, 4 and I would like to start the exploration of the tree close to the solution succ = [3, 1, 2, _] (actually it should be [3, 1, 2, 4] because of distinctness).
Thanks in advance for your answer.
All the best,
Luca
More information about the users
mailing list


This short tutorial on linear programming used to be part of the No bullshit guide to linear algebra, but was cut from the main text of the book, because it might not be interesting to all readers.
Business students will find this tutorial useful as it gives three points of view: - algorithmic (the steps of the simplex algorithm) - graphical (visual representation of the various coordinate systems used during algorithm) - numerical (practical computations using the computer algebr system SymPy)
This "feature cut" was done back in Jun 2015. Here is the commit message:
changeset: 185:3ca7ddf396f7
user: Ivan Savov
date: Sun Jun 14 11:35:15 2015 -0400
summary: Moved Linear Programming out of Applications chapter.

Will release it as a bonus free tutorial or something.
Readers interested in learning about linear algebra explained in a text that gets to the point should check out the book where this tutorial was supposed to appear: the No bullshit guide to linear algebra.
Feel free to use this text for you classes or tachings on LP. The license is MIT, a.k.a, do what you want with it.
The TikZ code used to generate the graphs is available upon request.


Generally a function is a "subprogram" that can be calles anywhere in your code, a function is composed of a sequance of statements called the function body. Values can be passed to a function, and the function will return a value.
variable
or by using the function
keyword.declare
your function which mean that you create the function by coding inside her, the second step is when you call
your function when you're done to write your function you maybe want execute the code inside her to do that you must call by using his name
.parameters
? parameters are data
inside ()
they are really helpful because you can call any type of datas objects, arrays, variable, number..
Parameters are used to call most of the times unknown datas who can interact inside of your function.if / else statements, loop, create array, object anything
.expressions functions
and statements functions
.expression function
is written by using variable
so if you want a call this function you must use the name of the variable. expression function
are using when you need to produce a value.statement function
is written by using the function keyword
follow by the name of your function, they are helpful when you need to perform an action
like our example above.functions
are object, so you can call within a function an other anonymous functions who is also an
object
.closure
which means that
closure
can access datas after the parent function was called.anonymous functions
, this is better for organize and reading code.()
, you can if you want store your function in a variable like i did or call in the global context without variable,
to call this function simply use an other
()
after the first and enter your parameters if you have one and that's it.callback function
is simply when you call later a function in parameter of an other function.callback function
, this is really helpful when you have a big function and you can split your function into separate functions to better organize your code.arrayCalc
function who takes two parameters the first one is an array of datas
and the second one is a function
.empty array
we gonna use this array to store our result, then we loop
through our array passed in parameter, finally we push in this array the result of our function
passed in parameter.call
your function you usally use ()
to say "execute this function", but when you use callback function you don't use ()
because you don't want execute the function Immediatly you want that your initial function call this one later in the execution so don't use ()
when you use callback function
.data privacy
in other terms everything inside your iide would be only available inside her
, which means that your code inside will not interact with the code inside your global context
. Iife are also practice when you have a piece of code who not gonna change inside your application.()
then your declare a function like you normally did, the little trick is at the end as you know iife created a private scope which means that you can only access data inside of the iife so you can't call iife in the global context
, so to call the iife you must use after the last )
and other collections of ()
who tells to javascript to execute the iife.parameters
in your iife, to use this parameters
include your datas when you declare your iife in the last ()
.


{% include header.html %} {% include nav.html %}
The altmetrics conference is over for another year! Thank you to all who attended (either in person or remotely) and contributed to a fun and thought-provoking few days.
We’re busy getting our thoughts together and will be soliciting your feedback shortly.
In the meantime, catch up on anything you missed on Twitter at #2amconf, recap the sessions via our YouTube channel and take a look at the write ups from our guest contributors on the 2:AM blog.


Career Objective :
A highly organized and hard-working individual looking for a responsible position to gain practical experience.
Educational Details :
| Course | Name of the Institution | Year of Passing | Percentage |
|---|---|---|---|
| B.tech (E.C.E) | Aditya Enginnering College | Pursuing | -- |
| intermediate(M.P.C) | sri chaitanya jr college | 2017 | 91 |
| S.S.C | sri chaitanya em school | 2015 | 95 |
Certifications :
- AWS Cloud Training digital badge Certification from Apssdc
- python Certification from spoken tutorial
Declaration :
SUBMIT
I here by declare that all the information contained in this resume is in accordance with facts or truths to my knowledge.
I take full responsibility for the correctness of the said information.
I take full responsibility for the correctness of the said information.


cloudmesh-cloud.cloudmesh.ssh.command.ssh
¶
Module Contents¶
Classes¶
-
class
cloudmesh-cloud.cloudmesh.ssh.command.ssh.
SshCommand
¶ Bases:
cloudmesh.shell.command.PluginCommand
-
do_ssh
(self, args, arguments)¶ - Usage:
ssh ssh config list [–output=OUTPUT] ssh config add NAME IP [USER] [KEY] ssh config delete NAME ssh host delete NAME ssh host add NAME ssh [–name=VMs] [–user=USERs] [COMMAND]
- Arguments:
NAME Name or ip of the machine to log in list Lists the machines that are registered and
the commands to login to them
- PARAMETERS Register te resource and add the given
parameters to the ssh config file. if the resource exists, it will be overwritten. The information will be written in /.ssh/config
- Options:
- -v
verbose mode
- --output=OUTPUT
the format in which this list is given formats includes cat, table, json, yaml, dict. If cat is used, it is just printed as is. [default: table]
- --user=USERs
overwrites the username that is specified in ~/.ssh/config
- --name=CMs
the names of the VMS to execute the command on
- Description:
- ssh config list
lists the hostsnames that are present in the ~/.ssh/config file
- ssh config add NAME IP [USER] [KEY]
registers a host i ~/.ssh/config file Parameters are attribute=value pairs Note: Note yet implemented
- ssh [–name=VMs] [–user=USERs] [COMMAND]
executes the command on the named hosts. If user is specified and is greater than 1, it must be specified for each vm. If only one username is specified it is used for all vms. However, as the user is typically specified in the cloudmesh database, you probably do not have to specify it as it is automatically found.
Examples:
ssh config add blue <IP_ADDRESS> blue
Adds the following to the !/.ssh/config file
- Host blue
HostName <IP_ADDRESS> User blue IdentityFile ~/.ssh/id_rsa.pub
-


You've just founded a tiny renewable energy business that's trying to power the entire US with renewable energy sources like solar and wind power. Your job is to generate 1000 GWh of energy using renewable plants. Along the way, you'll need to build, research, and expand. Are you up to the challenge?
You should start by building a basic plant in New York, your headquarters. Start the clock running by pressing the or button and wait till you earn some money.
Then go to the Business tab and research Fuel Cells, which are very profitable, and build some in your other cities. Keep the clock running, and once you earn enough money, start expanding to other cities. Continue this process until you've covered the whole US and are generating 1000 GWh!


QuiZZam! is the result of a school project where the case description is basically
Kahoot!
The idea is that we're supposed to solve this using REST, and tools like jQuery and some CSS to make it look nice.
Any third party libraries whose license require some form of mentioning/description will be placed on this page.
You might call this a "TODO" for now...
(TODO: Make this pretty at some point...)
https://datatables.net/ <-- MIT license


POODR - Ch4: Creating Flexible Interfaces
27 Apr 2015There is design detail that must be captured at this level but an object-oriented application is more than just classes. It is made up of classes but defined by messages. Classes control what’s in your source code repository; messages reflect the living, ani- mated application. Design, therefore, must be concerned with the messages that pass between ob- jects. It deals not only with what objects know (their responsibilities) and who they know (their dependencies), but how they talk to one another. The conversation be- tween objects takes place using their interfaces.
##Defining Public Interfaces The kitchen does many things but does not, thankfully, expose them all to its customers. It has a public interface that customers are expected to use; the menu. Within the kitchen many things happen, many other messages get passed, but these messages are private and thus invisible to customers. Each of your classes is like a kitchen. The class exists to fulfill a single responsibil- ity but implements many methods.
###Public Interfaces The methods that make up the public interface of your class comprise the face it presents to the world. They: • Reveal its primary responsibility • Are expected to be invoked by others • Will not change on a whim • Are safe for others to depend on • Are thoroughly documented in the tests
Private Interfaces
All other methods in the class are part of its private interface. They: • Handle implementation details • Are not expected to be sent by other objects • Can change for any reason whatsoever • Are unsafe for others to depend on • May not even be referenced in the tests
Domain objects are easy to find but they are not at the design center of your application. Instead, they are a trap for the unwary. If you fixate on domain objects you will tend to coerce behavior into them. Design experts notice domain objects without concentrating on them; they focus not on these objects but on the messages that pass between them. These messages are guides that lead you to discover other objects, ones that are just as necessary but far less obvious.
Before you sit at the keyboard and start typing you should form an intention about the objects and the messages needed to satisfy this use case.
Using Sequence Diagrams
There is a perfect, low-cost way to experiment with objects and messages: sequence diagrams. Therein lies the value of sequence diagrams. They explicitly specify the messages that pass between objects, and because objects should only communicate using public interfaces, sequence diagrams are a vehicle for exposing, experimenting with, and ultimately defining those interfaces.
Also, notice now that you have drawn a sequence diagram, this design conversation has been inverted. The previous design emphasis was on classes and who and what they knew. Suddenly, the conversation has changed; it is now revolving around mes- sages. Instead of deciding on a class and then figuring out its responsibilities, you are now deciding on a message and figuring out where to send it.
This transition from class-based design to message-based design is a turning point in your design career. The message-based perspective yields more flexible applications than does the class-based perspective. Changing the fundamental design question from “I know I need this class, what should it do?” to “I need to send this message, who should respond to it?” is the first step in that direction.
Asking for “What” Instead of Telling “How”
The distinction between a message that asks for what the sender wants and a message that tells the receiver how to behave may seem subtle but the consequences are significant. Understanding this difference is a key part of creating reusable classes with well-defined public interfaces.
Seeking Context Independence
The context that an object expects has a direct effect on how difficult it is to reuse. Objects that have a simple context are easy to use and easy to test; they expect few things from their surroundings. Objects that have a complicated context are hard to use and hard to test; they require complicated setup before they can do anything. The best possible situation is for an object to be completely independent of its context. An object that could collaborate with others without knowing who they are or what they do could be reused in novel and unanticipated ways. You already know the technique for collaborating with others without knowing who they are—dependency injection.
 This blind trust is a keystone of object-oriented design. It allows objects to collab- orate without binding themselves to context and is necessary in any application that expects to grow and change.
Create Explicit Interfaces
Your goal is to write code that works today, that can easily be reused, and that can be adapted for unexpected use in the future. Other people will invoke your methods; it is your obligation to communicate which ones are dependable. www.it-ebooks.info Writing Code That Puts Its Best (Inter)Face Forward 77 Every time you create a class, declare its interfaces. Methods in the public interface should • Be explicitly identified as such • Be more about what than how • Have names that, insofar as you can anticipate, will not change • Take a hash as an options parameter
Be just as intentional about the private interface; make it inescapably obvious. Tests, because they serve as documentation, can support this endeavor. Either do not test private methods or, if you must, segregate those tests from the tests of public methods. Do not allow your tests to fool others into unintentionally depending on the changeable, private interface. Ruby provides three relevant keywords: public, protected, and private. Use of these keywords serves two distinct purposes. First, they indicate which methods are stable and which are unstable. Second, they control how visible a method is to other parts of your application. These two purposes are very different. Conveying informa- tion that a method is stable or unstable is one thing; attempting to control how others use it is quite another. Public, Protected, and Private Keywords The private keyword denotes the least stable kind of method and provides the most restricted visibility. Private methods must be called with an implicit receiver, or, inversely, may never be called with an explicit receiver.
The protected keyword also indicates an unstable method, but one with slightly different visibility restrictions. Protected methods allow explicit receivers as long as the receiver is self or an instance of the same class or subclass of self.
Honor the Public Interfaces of Others Do your best to interact with other classes using only their public interfaces.f your design forces the use of a private method in another class, first rethink your design. It’s possible that a committed effort will unearth an alternative; you should try very hard to find one. A dependency on a private method of an external framework is a form of technical debt. Avoid these dependencies.
Minimize Context Construct public interfaces with an eye toward minimizing the context they require from others. Keep the what versus how distinction in mind; create public methods that allow senders to get what they want without knowing how your class implements its behavior.
Do what best suits your needs, but create some kind of defined public interface and use it. This reduces your class’s context, making it easier to reuse and simpler to test.


|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
public interface Query<T>
This is similar to the datastore Query object, but better understands real class objects - it allows you to filter and sort by the key field normally.
The methods of this class follow the GAE/Python Query class rather than the GAE/Java Query class because the Python version is much more convenient to use. The Java version seems to have been designed for machines, not humans. You will appreciate the improvement.
Construct this class by calling Objectify.query()
Note that this class is Iterable itself; you do not need to call the fetch() method, but it is available if you like it.
To obtain a Cursor
call Query.iterator().getCursor()
.
This cursor can be resumed with Query.cursor()
.
| Method Summary | ||
|---|---|---|
Query<T> |
ancestor(java.lang.Object keyOrEntity)
Restricts result set only to objects which have the given ancestor somewhere in the chain. |
|
int |
countAll()
Count the total number of values in the result, ignoring limit and offset. |
|
Query<T> |
cursor(com.google.appengine.api.datastore.Cursor value)
Starts query results at the specified Cursor. |
|
com.google.appengine.api.datastore.QueryResultIterable<T> |
fetch()
Execute the query and get the results. |
|
com.google.appengine.api.datastore.QueryResultIterable<Key<T>> |
fetchKeys()
Execute the query and get the keys of the results. |
|
|
fetchParentKeys()
Execute a keys-only query and then extract parent keys, returning them as a Set. |
|
|
fetchParents()
Gets the parent keys and then fetches the actual entities. |
|
Query<T> |
filter(java.lang.String condition,
java.lang.Object value)
Create a filter based on the specified condition and value, using the same syntax as the GAE/Python query class. |
|
T |
get()
Gets the first entity in the result set. |
|
Key<T> |
getKey()
Get the key of the first entity in the result set. |
|
Query<T> |
limit(int value)
Limit the fetched result set to a certain number of values. |
|
Query<T> |
offset(int value)
Starts the query results at a particular zero-based offset. |
|
Query<T> |
order(java.lang.String condition)
Sorts based on a property. |
|
java.lang.String |
toString()
Generates a string that consistently and uniquely specifies this query. |
| Methods inherited from interface com.google.appengine.api.datastore.QueryResultIterable |
|---|
iterator |
| Method Detail |
|---|
Query<T> filter(java.lang.String condition, java.lang.Object value)
Create a filter based on the specified condition and value, using the same syntax as the GAE/Python query class. Examples:
filter("age >=", age)
filter("age =", age)
filter("age", age)
(if no operator, = is assumed)filter("age !=", age)
filter("age in", ageList)
You can filter on id properties if this query is
restricted to a Class
You can not filter on @Parent properties. Use
the ancestor()
method instead.
Query<T> order(java.lang.String condition)
Sorts based on a property. Examples:
sort("age")
sort("-age")
(descending sort)You can sort on id properties if this query is
restricted to a Class
You can not sort on @Parent properties.
Query<T> ancestor(java.lang.Object keyOrEntity)
keyOrEntity
- can be a Key, a KeyQuery<T> limit(int value)
value
- must be >= 0. A value of 0 indicates no limit.Query<T> offset(int value)
value
- must be >= 0Query<T> cursor(com.google.appengine.api.datastore.Cursor value)
java.lang.String toString()
Generates a string that consistently and uniquely specifies this query. There is no way to convert this string back into a query and there is no guarantee that the string will be consistent across versions of Objectify.
In particular, this value is useful as a key for a simple memcache query cache.
toString
in class java.lang.Object
T get()
Key<T> getKey()
com.google.appengine.api.datastore.QueryResultIterable<T> fetch()
com.google.appengine.api.datastore.QueryResultIterable<Key<T>> fetchKeys()
<V> java.util.Set<Key<V>> fetchParentKeys()
java.lang.IllegalStateException
- if any member of the query result does not have a parent.<V> java.util.Map<Key<V>,V> fetchParents()
ofy.get(query.fetchParentKeys())
.
java.lang.IllegalStateException
- if any member of the query result does not have a parent.int countAll()
Count the total number of values in the result, ignoring limit and offset.
This is somewhat faster than fetching, but the time still grows with the number of results.
|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


This page tracks the new paper links made to our list of SIGGRAPH 2008 papers.
Page maintained by Ke-Sen Huang.
If you have additions or changes, send an e-mail.
November 27 2009
- Added ACM DOI link for each paper
- Watertight Trimmed NURBS
October 7, 2008
September 4, 2008
August 26 2008
August 6 2008
August 4 2008
July 31 2008
July 27 2008
July 25 2008
July 16 2008
July 11 2008
July 2 2008
July 1 2008
June 30 2008
June 27 2008
June 24 2008
June 20 2008
June 18 2008
June 13 2008
June 12 2008
June 10 2008
June 7 2008
June 3 2008
June 1 2008
May 31 2008
May 29, 2008
May 27, 2008
May 26, 2008
May 24, 2008
- Simulating Knitted Cloth at the Yarn Level
May 22, 2008
May 21, 2008
May 20, 2008
- Face Swapping: Automatic Face Replacement in Photographs
May 19, 2008
May 18, 2008
May 16, 2008
May 15, 2008
May 14, 2008
May 13, 2008
May 11, 2008
May 10, 2008
May 9, 2008
May 8, 2008
May 7, 2008
May 6, 2008
May 4, 2008
May 3, 2008
May 2, 2008
May 1, 2008
April 30, 2008
April 29, 2008
April 28, 2008
April 26, 2008
- Markerless Garment Capture
- Articulated Mesh Animation from Multi-view Silhouettes
- Interactive Simulation of Stylized Human Locomotion
April 24, 2008
April 23, 2008
- Glare Aware Photography: 4D Ray Sampling for Reducing Glare Effects of Camera Lenses
- A Perceptually Validated Model for Surface Depth Hallucination
- Bubbles Alive
April 22, 2008
- Lapped Solid Textures: Filling a Model with Anisotropic Textures (Project)
April 21, 2008
- Interactive Procedural Street Modeling
- A System for High-Volume Acquisition and Matching of Fresco Fragments: Reassembling Theran Wall Paintings
- Performance Capture from Sparse Multi-view Video.
- Fluorescent Immersion Range Scanning
- Towards Passive 6D Displays for Relighting
April 20, 2008
- Unwrap Mosaics: A new representation for video editing
- Continuation Methods for Adapting Simulated Skills
April 18, 2008
- Dual Scattering Approximation for Fast Multiple Scattering in Hair (Project)
- 3D Unsharp Masking for Scene Coherent Enhancement
April 17, 2008
- A Perception-based Color Space for Illumination-invariant Image Processing
- Diffusion Curves: A Vector Representation for Smooth-Shaded Images (Project)
April 16, 2008
- Automatic Generation of Tourist Maps
- Automated generation of interactive 3D exploded view diagrams
April 14, 2008
April 12, 2008
- Multiscale Texture Synthesis
April 11, 2008
- Perception of Complex Aggregates
- Fast Viscoelastic Behavior with Thin Features
April 9, 2008
- Self-Animating Images: Illusory Motion Using Repeated Asymmetric Patterns (Project)
- Progressive Inter-scale and intra-scale Non-blind Image Deconvolution
- BSGP: Bulk-Synchronous GPU Programming
- Example-Based Dynamic Skinning in Real-Time
- Interactive Relighting of Dynamic Refractive Objects
- Real-Time Smoke Rendering Using Compensated Ray Marching
April 7, 2008
- Finding Paths through the World's Photos
- High-Quality Motion Deblurring From a Single Image
- Clone Attack! Perception of Crowd Variety
- Motion Invariant Photography
April 6, 2008
April 4, 2008
- Upright Orientation of Man-Made Objects (Project)
- Skeleton Extraction by Mesh Contraction (Project)
- Structure-aware Halftoning
- Self-Animating Images: Illusory Motion Using Repeated Asymmetric Patterns
- Discovering Structural Regularity in 3D Geometry
- Discovering Structural Regularity in 3D Geometry (Project)
- 4-points Congruent Sets for Robust Surface Registration (Project)
- Curved Folding (Project)
- Programmable Aperture Photography: Multiplexed Light Field Acquisition
- Glare Photography
April 3, 2008
- Real-Time, All-Frequency Shadows in Dynamic Scenes
- Parallel Poisson Disk Sampling (TR)
- Multidimensional Adaptive Sampling and Reconstruction for Ray Tracing
- Hair Photobooth: Geometric and Photometric Acquisition of Real Hairstyles
April 2, 2008
- Data-driven Modeling of Skin and Muscle Deformation
- Real-time Gradient-domain Painting
- Backward Steps in Rigid Body Simulations
- Parallel Poisson Disk Sampling
- Inverse Texture Synthesis (TR)
kesen.huang@gmail.com


--- layout: post title: 'ah-yes-its-been-a-while-since-i-wrote-the-last' date: '2009-12-30T03:20:28+01:00' tags: [jsconfeu] category: 'Programming' tumblr_url: http://andywenk.tumblr.com/post/307149887/ah-yes-its-been-a-while-since-i-wrote-the-last ---
Ah yes,
it’s been a while since I wrote the last post and I planned to write something about the second day @jsconfeu a little sooner. But a lot of work (a lot JS work actually ;-) ) kept me away from doing so. Anyway - here we go.
#slides #video
The second day (with not that big hangover as at the first day) started with some Webdesign topics presented by Amy Hoy (@amyhoy). She’s really a nice guy and “hanging around” with the author of script.aculo.us Thomas Fuchs. Basically she was…


To get more information about message move cursor over it.
{{error}}
Great work! No issues were found!


[gecode-users] Re: Var indexes-help
Mikael Zayenz Lagerkvist
zayenz at gmail.com
Tue Jan 9 08:10:37 CET 2007
On 1/8/07, penche <penche21 at hotmail.com> wrote:
> <pekczynski at ...> writes:
>
> >
> > Hi there,
> > I think using the element constraint is the correct choice.
> > Maybe the little example I attached will help you out.
> > At least you can use the element constraint to model
> >
> > B[C[i-1]]=A[i]
> >
> > and indeed the alg also does
> >
> > A[i]=B[C[i-1]]
> >
> > see http://www.gecode.org/gecode-doc-latest/group__TaskIntIntElement.html
> >
> > > 2) I also tried 'element' to express this constraint
> > >
> > > Int Var x;
> > > element(this, B, C.get(i - 1), x);
> > > rel(this,A.get(i),IRT_EQ,x);
> >
> > So this was quite right, but you can directly use
> >
> > element(this, B, C[i - 1], A[i]);
> >
> > so you don't need the rel constraint.
> >
> > If there are any further questions, let us know.
> > :-D
> > Cheers
> > Patrick
> >
> >
> > Attachment (arrayex.cc): application/octet-stream, 1932 bytes
> >
> > _______________________________________________
> > Gecode users mailing list
> > users at ...
> > https://www.gecode.org/mailman/listinfo/gecode-users
> >
>
> Thank you, I now see rel is useless and element is just enough.
> But one point is; we will need Var indexes inevitable when the relations
> get nested.
>
> For example; A[i] = B [ C [A[j]] ]
>
> 1) obviously rel does not work.
> rel(this, A.get(i), IRT_EQ, B.get(C.get(A.get(j))))
>
> 2) I tried to introduce new Vars, but below did not work also.
>
> IntVar intermediate1= new IntVar(this,min,max);
> IntVar intermediate2= new IntVar(this,min, max);
>
> element(this, C, A.get(j), intermediate1);
> element(this, B, intermediate1, intermediate2);
>
> rel(this, A.get(i), IRT_EQ, intermediate2);
>
> 3) Any way to write this constraint?
The element constraint implements A[I]=V where A is a VarArray of
integer variables and I and V are integer variables. If you want your
index variable to be looked up in another variable array, then this is
another element constraint. Thus something like 2 is the correct way
to model your desired constraints.
One thing to note is that you can skip intermediate2, and directly
replace it with A.get(i). This gives the following code:
IntVar intermediate1= new IntVar(this,min,max);
element(this, C, A.get(j), intermediate1);
element(this, B, intermediate1, A.get(j));
this implements B[C[A[i]]] = A[j]. The only direct reason I see that
this would not work is if min and max are wrong. Safe, unconstraining
bounds are min=0 and max=B.size().
Cheers,
Mikael
--
Mikael Zayenz Lagerkvist, http://www.ict.kth.se/~zayenz/
More information about the gecode-users
mailing list


enter a statement or sentence and a trained logistical regression model will determine the sentiment of your statement!


People often want to terminate their Loops before they reach the designated number of trials based on subjects’ responses. For example, you might want to use a Loop to repeat a sequence of images that you want to continue until a key is pressed, or use it to continue a training period, until a criterion performance is reached.
To do this you need a Code Component inserted into your routine. All loops have an attribute called finished which is set to True or False (in Python these are really just other names for 1 and 0). This finished property gets checked on each pass through the loop. So the key piece of code to end a loop called trials is simply:
trials.finished=True #or trials.finished=1 if you prefer
Of course you need to check the condition for that with some form of if statement.
Example 1: You have a change-blindness study in which a pair of images flashes on and off, with intervening blanks, in a loop called presentationLoop. You record the key press of the subject with a Keyboard Component called resp1. Using the ‘ForceEndTrial’ parameter of resp1 you can end the current cycle of the loop but to end the loop itself you would need a Code Component. Insert the following two lines in the End Routine parameter for the Code Component, which will test whether more than zero keys have been pressed:
if len(resp1.keys)>0:
presentationLoop.finished=1
Example 2: Sometimes you may have more possible trials than you can actually display. By default, a loop will present all possible trials (nReps * length-of-list). If you only want to present the first 10 of all possible trials, you can use a code component to count how many have been shown, and then finish the loop after doing 10.
This example assumes that your loop is named ‘trials’. You need to add two things, the first to initialize the count, and the second to update and check it.
Begin Experiment:
myCount = 0
Begin Routine:
myCount = myCount + 1
if myCount > 10:
trials.finished = True
Note
In Python there is no end to finish an if statement. The content of the if or of a for-loop is determined by the indentation of the lines. In the above example only one line was indented so that one line will be executed if the statement evaluates to True.