Transforming the Afro-Caribbean World: Visualized
As part of the Transforming the Afro-Caribbean World (TAW) project, team members identified, photographed, and transcribed a selection of records from the U.S. National Archives and Records Administration (NARA) relevant to historical research on labor migration to the Panama Canal region between 1880 and 1918.
The project's graduate research assistants transcribed these records, chiefly applications for "Photo Metal Checks," into spreadsheets — versions of which power the visualizations below. The values of several key fields, such as place of birth and, to a lesser extent, occupation were normalized using Open Refine.
Based on this exploratory work, two approaches to visualizing this data suggest themselves: 1) geospatial; and 2) categorical/hierarchical. Below, an example of each of these visualization strategies forms the context for a short discussion of what the current state of the data will allow as well as possibilities for future work.
Seeing Movement
The records used in this project contain several different types of geospatial information — explicit and implied — that can be used to visualize the movement of workers through space and time. Examples include but are not limited to:
- country/territory of birth
- date of arrival on the isthmus
- local isthmian address upon migration
- location of employment
In it's current state, the data supports visualizing only the grossest of these geospatial and temporal relationships describing the migration of workers. Almost all of the transcribed records contain information about country of birth. The granularity of dates of arrival varies across this set: some records have full day, month, and year information, some only month and year, or year. Thus, taking country of birth as a stand-in for the beginning of a worker's journey (a vastly simplifying assumption), it becomes possible to visualize variations in origin of workers migrating to the canal zone between 1880 and 1918.
Given further work to acquire historic maps of the canal zone during the period of construction and to geolocate (provide latitude and longitude coordinates) places within the canal zone that are currently referred to in the dataset only by name, it might be possible to map workers' journies within the ambit of the canal project and not just from another country of origin to the canal zone.
Seeing Workers
Workers' records capture information about a number of other attributes (skin color, at least as interpreted by canal officials; job category; literacy; marital status; etc.). Using categorical/hierarchical approaches it is also possible to begin to visualize the distribution of workers with various attributes.
Some of the most interesting of these attributes such as occupation have been only lightly normalized. Further work categorizing these elements of the data might produce new and more interesting groupings.
This type of visualization might be combined — as a rich browsing interface — with the full text of documents such as the essays written by former canal workers collected by the TAW project to provide even more rich detail about these historical people.


genes expression ovule integument Arabidopsis gene expressed outer Plant Atg ino using development ant identified inner protein file family integuments Cell mutant specific analysis fold transcription cell wild type growth changes primordia used embryo proteins (Figure arrays levels mutants set ovules putative Genes data showed likely shown known {border-style decreased situ genes, hybridization patterns px;} stage stages #ffffff;} Biol decrease early floral involved --- Physiol array carpel genes. predicted regions relative similar (), ./pp.. ./tpc... Gasser cells change number organ plant values Development lower regulators results Expression auxin cluster different factors formation identify later primordia, zinc Additional Sci binding dchip finger pattern significant Click Dev LINK described development, encodes factor group indicated level microarray pistils pollen samples structures (Additional Figure candidate development. differences domain indicating integument, nucellus observed plants region regulation replicates reverse sac significantly ARF ATHB Acad DNA EARLY INO Natl Nature Proc USA absent affected based clusters collected comparison developmental evidence expression. fusion gametophyte gene, groups high higher homeodomain integument. low medial members methods pistil placenta profiles putatively qRT-PCR -fold AINTEGUMENTA Affymetrix Meyerowitz Mol SOM candidates changed control development) fluorescence formed greater identification identity important integuments, meristem processed px; quantitative regulated regulates seen sequence studies thaliana {font-family ./dev. ./j.-X...x ./pnas... ./tpc.. Analysis Hauser MADS-box REM RMA RNA Yanofsky addition, ant, contains effects font-size form genome good including indicates integument; integuments. layer limma mutants. organs possible seed sets test transcriptional (A) (floral ./S-()- AGF Bowman DNA-binding Genome Krizek Schneitz Skinner Smyth acid act acting approximately arrays, carpels class compared comparisons complete confirmed considered double; flower following function function. functions funiculus genotypes included information ino. localized loss mRNA novel obtained ovules, patterning performed previously profiling reproductive role sacs selected type) use value zipper > (Atg) (B) ./gad... ./tpc. APETALA Atg, CA) CA). Curr Ditta Early Eshed GFP Genetic Genetics However, LATE MADS NGA Ovules PCR Regulation Robinson-Beers SUPERMAN WRKY Wisman YABBY ant. basis biological border-color border-width broad cDNA chalaza changes. combination cut determined discovery enzymes expected expression, families gynoecium homeotic interaction late limited maintained match mature method multiple nature numbers pair-wise phenotype predominantly probe proteins, reduced required roles shows solid; spatial specifically statistical study target targets tests, types uncharacterized wildtype {font-style {font-weight (WT -IV ./nature AGAMOUS ANT ATS Approximately Colombo Dharmasiri Fischer Gene Grossniklaus Hill Identification MPSS Meister RT-PCR Research SHP Spe Sun TAZ Table Yang aRNA accumulation action additional amino analysis. arrays. better bold callose characterization chosen complex confidence contained controls correlation courier; database decreases detected difference differential differentiation distal domains em; encoding evaluation examined experimental female final funiculus; gene. general genomic genotype highest images includes increased indicate inflorescences initiation interactions just lack lateral layers lines listed little mean microscope mutant, mutants, myb negative new normalization nucellus. oi, oligonucleotide order pDS. pair patterns, perfect phenotypes polarity predictions processes promoter protein, pt;} published reaction receptor reduction regulator related replicates, replicates. resulting retained ring sample seventeen shown). size strong successful temporal tested tissue total transcriptome wild-type work


--- title: "Using R to analyse the Roche Antigen Rapid Test: How accurate is it?" author: "Gertjan Verhoeven" date: '2021-06-06' summary: This blog post is about the Roche Rapid Antigen Test Nasal. How accurate is it? I tracked down the data mentioned in the kit's leaflet, discuss the whole measurement process and used R to reproduce the sensitivity and specificity of the test. slug: covid_antigen_test_reliability draft: no categories: - Statistics - Data science - Measurement tags: - COVID-19 - DAG - causal graph - Bayesian statistics baseurl: https://gsverhoeven.github.io header: image: headers/covid_antigen_test.png preview: no ---
(Image is from a different antigen test)
Many people are suspicious about the reliability of rapid self-tests, so I decided to check it out. For starters, I LOVE measurement. It is where learning from data starts, with technology and statistics involved. With this post, I’d like to join the swelling ranks of amateur epidemiologists :) I have spent a few years in a molecular biology lab, that should count for something right?
At home, we now have a box of the SARS-CoV-2 Rapid Antigen Test Nasal kit. The kit is distributed by Roche, and manufactured in South Korea by a company called SD Biosensor.
So how reliable is it? A practical approach is to compare it to the golden standard, the PCR test, that public health test centers use to detect COVID-19. Well, the leaflet of the kit describes three experiments that do exactly that! So I tracked down the data mentioned in the kit’s leaflet, and decided to check them out.
But before we analyze the data, you want to know how they were generated, right? RIGHT? For this we use cause-effect diagrams (a.k.a. DAGs), which we can quickly draw using DAGitty.
The cool thing about DAGitty is that we can use a point-n-click interface to draw the diagram, and then export code that contains an exact description of the graph to include in R. (You can also view the graph for this blog post at DAGitty.net):
The graph is based on the following description of the various cause-effect pairs:
It all starts with whether someone is infected. After infection, virus particles start to build up. These particles can be in the lungs, in the throat, nose etc. These particles either do or do not cause symptoms. Whether there are symptoms will likely influence the decision to test, but there will also be people without symptoms that will be tested (i.e. if a family member was tested positive).
In the experiments we analyze, two samples were taken, one for the PCR test and one for the antigen test. The way the samples were taken differed as well: “shallow” nose swabs for the rapid antigen test, and a combination of “deep” nose and throat swabs for the PCR test.
Now that we now a bit about the measurement process, lets look at how the accuracy of the antigen test is quantified.
The PCR test result serves as the ground truth, the standard to which the antigen test is compared. Both tests are binary tests, either it detects the infection or it does not (to a first approximation).
For this type of outcome, two concepts are key: the sensitivity (does the antigen test detect COVID when the PCR test has detected it) and specificity of the test (does the antigen test ONLY detect COVID, or also other flu types or even unrelated materials, for which the PCR test produces a negative result).
The leaflet contains information on both.
But what does this really tell us? And where do these numbers come from?
Before we go to the data, we first need to know a bit more detail on what we are actually trying to measure, the viral load, and what factors influence this variable.
Now that we have some background info, we are ready to check the data!
As mentioned above, this data came from three experiments on samples from in total 547 persons.
After googling a bit, I found out that the experiments were performed by independent researchers in a famous University hospital in Berlin, Charité. After googling a bit more and mailing with one of the researchers involved, Dr. Andreas Lindner, I received a list of papers that describe the research mentioned in the leaflet (References at the end of this post).
The dataset for the blog post compares nasal samples tested with the Roche Antigen test kit, to PCR-tested nasopharyngeal plus oropharyngeal samples taken by professionals.
This blog post is possible because the three papers by Lindner and co-workers all contain the raw data as a table in the paper. Cool!
Unfortunately, this means the data is not machine readable. However, with a combination of manual tweaking / find-replace and some coding, I tidied the data of the three studies into a single tibble
data frame. You can grab the code and data from my Github.
UPDATE: Rein Halbersma showed me how to use web scraping to achieve the same result, with a mere 20 lines of code of either Python or R! Cool! I added his scripts to my Github as well, go check them out, I will definitely go this route next time.
# creates df_pcr_pos
source("sars_test/dataprep_roche_test.R")
# creates df_leaflet
source("sars_test/dataprep_roche_test_leaflet.R")
# see below
source("sars_test/bootstrap_conf_intervals.R")
The dataset df_pcr_pos
contains, for each PCR positive patient:
ct_value
viral_load
days_of_symptoms
mm_value
(Result of a nasal antigen test measurement, 1 is positive, 0 is negative)To understand the PCR data, we need to know a bit more about the PCR method.
The PCR method not only measures if someone is infected, it also provides an estimate of the viral load in the sample. How does this work? PCR can amplify, in so-called cycles, really low quantities of viral material in a biological sample. The amount of cycles of the PCR device needed to reach a threshold of signal is called the cycle threshold or Ct value. The less material we have in our sample, the more cycles we need to amplify the signal to reach a certain threshold.
Because the amplification is an exponential process, if we take the log of the number of virus particles, we get a linear inverse (negative) relationship between ct_value and viral_load. For example, \(10^6\) particles is a viral load of 6 on the log10 scale.
So let’s plot the ct_value
of the PCR test vs the viral_load
:
set.seed(123)
ggplot(df_pcr_pos, aes(x = ct_value, y = viral_load, color = factor(pcr_assay_type))) +
geom_point() + ggtitle("Calibration curves for viral load (log10 scale)")
This plot shows that viral_load
is directly derived from the ct_value
through a calibration factor.
PCR Ct values of > 35 are considered as the threshold value for detecting a COVID infection using the PCR test, so the values in this plot make sense for COVID positive samples.
Take some time to appreciate the huge range difference in the samples on display here. From only 10.000 viral particles (\(log_{10}{(10^4)} = 4\) ) to almost 1 billion (\(log_{10}{(10^9)} = 9\) ) particles.
We can also see that apparently, there were two separate PCR assays (test types), each with a separate conversion formula used to obtain the estimated viral load.
(N.b. The missings for pcr_assay_type
are because for two of three datasets, it was difficult to extract this information from the PDF file. From the plot, we can conclude that for these datasets, the same two assays were used since the values map onto the same two calibration lines)
The dataset contains all samples for which the PCR test was positive. Let’s start by checking the raw percentage of antigen test measurements that are positive as well. This is called the sensitivity of a test.
res <- df_pcr_pos %>%
summarize(sensitivity = mean(mm_value),
N = n())
res
## # A tibble: 1 x 2
## sensitivity N
## <dbl> <int>
## 1 0.792 120
So for all PCR positive samples, 79.2 % is positive as well. This means that, on average, if we would use the antigen test kit, we have a one in five (20%) probability of not detecting COVID-19, compared to when we would have used the method used by test centers operated by the public health agencies.
This value is slightly lower, but close to what is mentioned in the Roche kit’s leaflet.
Let’s postpone evaluation of this fact for a moment and look a bit closer at the data.
For example, we can example the relationship between viral_load
and a positive antigen test result (mm_value
= 1):
table(df_pcr_pos$mm_value, df_pcr_pos_np$mm_value)
##
## 0 1
## 0 20 5
## 1 5 90
set.seed(123)
ggplot(df_pcr_pos, aes(x = viral_load, y = mm_value)) +
geom_jitter(height = 0.1) +
geom_smooth() +
geom_vline(xintercept = c(5.7, 7), col = "red")
From this plot, we can see that the probability of obtaining a false negative result (mm_value
of 0) on the antigen test decreases as the viral load of the PCR sample increases.
From the data we also see that before the antigen test to work about half of the time (blue line at 0.5), the PCR sample needs to contain around \(5 \cdot 10^5\) viral particles (log10 scale 5.7), and for it to work reliably, we need around \(10^7\) particles (“high” viral load) in the PCR sample (which is a combination of oropharyngeal and nasopharyngeal swab). This last bit is important: the researchers did not measure the viral load in the nasal swabs used for the antigen test, these are likely different.
For really high viral loads, above \(10^7\) particles in the NP/OP sample, the probability of a false negative result is only a few percent:
df_pcr_pos %>% filter(viral_load >= 7) %>%
summarize(sensitivity = mean(mm_value),
N = n())
## # A tibble: 1 x 2
## sensitivity N
## <dbl> <int>
## 1 0.972 71
Ok, so the rapid antigen test is less sensitive than PCR. What about the effect of using self-administered nasal swabs, versus professional health workers taking a nasopharyngeal swab (and often a swab in the back of the throat as well)?
Interestingly, the three Berlin studies all contain a head-to-head comparison of nasal versus nasopharygeal (NP) swabs. Lets have a look, shall we?
The dataset df_pcr_pos_np
is identical to df_pcr_pos
, but contains the measurement results for the nasopharygeal swabs.
To compare both measurement methods, we can plot the relationship between the probability of obtaining a positive result versus viral load. If one method gathers systematically more viral load from the patient, we expect that method to detect infection at lower patient viral loads, and the curves (nasal vs NP) would be shifted relative to each other.
set.seed(123)
ggplot(df_pcr_pos_np , aes(x = viral_load, y = mm_value)) +
geom_jitter(data = df_pcr_pos, height = 0.05, col = "blue") +
geom_jitter(height = 0.05, col = "orange") +
geom_smooth(data = df_pcr_pos , col = "blue") +
geom_smooth(col = "orange") +
ggtitle("nasal (blue) versus nasopharyngeal (orange) swabs")
By fitting a smoother through the binary data, we obtain an estimate of the relationship between the probability of obtaining a positive result, and the viral load of the patient as measured by PCR on a combined NP/OP swab.
From this plot, I conclude that:
This last conclusion came as a surprise for me, as nasopharygeal swabs are long considered to be the golden standard for obtaining samples for PCR detection of respiratory viruses, such as influenza and COVID-19 (Seaman et al. (2019), (Lee et al. 2021) ). So let’s look a bit deeper still.
We can compare the results from the three Berlin studies with a recent Dutch study that also used the Roche antigen test (ref: Igloi et al. 2021). The study was conducted in Rotterdam, and used nasopharygeal swabs to obtain the sample for the antigen test.
Cool! Lets try and create two comparable groups in both studies so we can compare the sensitivity.
The Igloi et al. paper reports results for a particular subset that we can also create in the Berlin dataset. They report that for the subset of samples with high viral load (viral load \(2.17 \cdot 10^5\) particles / ml = 5.35 on the log10 scale, ct_value <= 30) AND who presented within 7 days of symptom onset, they found a sensitivity of 95.8% (CI95% 90.5-98.2). The percentage is based on N = 159 persons (or slightly less because of not subsetting on <= 7 days of symptoms, the paper is not very clear here).
We can check what the sensitivity is for this subgroup in the Berlin dataset:
df_pcr_pos %>% filter(viral_load >= 5.35 & days_of_symptoms <= 7) %>%
summarize(sensitivity = mean(mm_value),
N = n())
## # A tibble: 1 x 2
## sensitivity N
## <dbl> <int>
## 1 0.898 88
In the same subgroup of high viral load, sensitivity of the nasal swab test is 6% lower than the nasopharyngeal swab test, across the two studies. But how do we have to weigh this evidence? N = 88 is not so much data, and the studies are not identical in design.
Importantly, since the threshold to be included in this comparison (ct value <= 30, viral_load > 5.35) contains a large part of the region where the probability of a positive result is between 0 and 1, we need to compare the distributions of viral loads for both studies to make an apples to apples comparison.
The Igloi study reports their distribution of viral loads for PCR-positive samples (N=186) in five bins (Table 1 in their paper):
cat <- c("ct <= 20", "ct 20-25", "ct 25-30", "ct 30-35", "ct 35+")
counts <- c(31, 82, 46, 27, 1)
ggplot(data.frame(cat, counts), aes(x = cat, y = counts)) +
geom_col()
Lets create those same bins in the Berlin dataset as well:
df_pcr_pos$ct_bin <- cut(df_pcr_pos$ct_value, breaks = c(-Inf,20,25,30,35,Inf))
ggplot(df_pcr_pos, aes(x = ct_bin)) +
geom_histogram(stat = "count")
For the subset where we can compare the sensitivities (ct_value <= 30), the Berlin clinical population has a higher viral load than the Rotterdam clinical population! So that does not explain why the Rotterdam study reports a higher sensitivity.
I use simulation to create distributions of plausible values for the sensitivity, assuming the observed values in both studies (89.7% for the Berlin studies, and 95.8% for the Rotterdam study) to be the true data generating values.
set.seed(123)
# Berlin
sample_size = 88
prior_probability = 0.898
est_p <- rbinom(10000, sample_size, p=prior_probability)/sample_size
# Rotterdam
sample_size2 = 159 # derived from Table 1 (Ct value distribution of PCR+ samples, <= 30)
prior_probability2 = 0.958
est_p2 <- rbinom(10000, sample_size2, p=prior_probability2)/sample_size2
ggplot(data.frame(est_p), aes(x = est_p)) +
geom_histogram(binwidth = 0.005) +
geom_histogram(data = data.frame(est_p = est_p2), fill = "gray60", alpha = 0.5, binwidth = 0.005) +
geom_vline(xintercept = prior_probability, linetype = "dashed", col= "red") +
geom_vline(xintercept = prior_probability2, linetype = "dashed", col= "blue") +
ggtitle("Berlin (black bars) vs Rotterdam (grey bars) sensitivity for higher viral loads")
There is a region of overlap between the two distributions, so the difference between the studies could be (in part) attributed to statistical sampling variation for the same underlying process.
I conclude that the Berlin study, who does a head to head comparison of NP versus nasal swabs, finds them to be highly comparable, and reports sensitivities that are close to those reported by the Rotterdam study.
Surprisingly, nasal swabs appear to give results that are comparable to those of nasopharyngeal swabs, while having not having the disadvantages of them (unpleasant, can only be performed by professional health worker).
So far, the discussion centered around the sensitivity of the test. Equally important is the specificity of the test. This quantifies if the test result of the antigen test is specific for COVID-19. It would be bad if the test would also show a result for other viruses, or even unrelated molecules.
To examine this, we use the aggregated data supplied on the leaflet from the kit, df_leaflet
.
N.b. The aggregated data is a subset of all the data from the three studies, because the data was subsetted for cases with <= 7 days_of_symptoms
.
This dataset contains for each sample one of four possibilities:
We use the yardstick
package of R’s tidymodels
family to create the 2x2 table and analyze the specificity.
(Overthinking: Note that the yardstick
package is used to quantify the performance of statistical prediction models by comparing the model predictions to the true values contained in the training data. This provides us with an analogy where the antigen test can be viewed as a model that is trying the predict the outcome of the PCR test.)
options(yardstick.event_first = FALSE)
conf_matrix <- yardstick::conf_mat(df_leaflet, pcr_result, ag_result)
autoplot(conf_matrix,
type = "heatmap",
title = "Truth = PCR test, Prediction = Antigen test")
From the heatmap (confusingly called a confusion matrix among ML practioners), we see that:
For the specificity, we have to look at the samples where the PCR test is negative, but the antigen test is positive, and compare these to all the samples that are PCR-test negative. These are the number of tests where the antigen test picked up a non-specific signal. One minus this percentage gives the specificity (1 - 4/435 = 431/435):
yardstick::spec(df_leaflet, pcr_result, ag_result)
## # A tibble: 1 x 3
## .metric .estimator .estimate
## <chr> <chr> <dbl>
## 1 spec binary 0.991
Thus, we find that the antigen test is highly specific, with around 1% of false positives.
So far, we did not discuss the sampling variability in the estimated specificity and sensitivity.
The kit leaflet mentions the following confidence intervals:
The R-package yardstick
does not yet include confidence intervals, so I generated these using bootstrapping. I calculate both metrics for 10.000 samples sampled from the raw data. For brevity I omitted the code here, go check out my Github for the R script.
The bootstrapping approach yields the following range of plausible values given the data (95% interval):
quantile(spec_vec, probs = c(0.025, 0.975))
## 2.5% 97.5%
## 0.9811765 0.9977477
quantile(sens_vec, probs = c(0.025, 0.975))
## 2.5% 97.5%
## 0.7570030 0.9029126
The amount of data (N = 537) prevents us from getting an exact match to the leaflet’s confidence intervals, that are based on theoretic formulas. But we do get pretty close.
Especially for the sensitivity, there is quite some uncertainty, we see that plausible values range from 76% up to 90% for this particular cohort of cases with this particular mix of viral loads that showed up during the last four months of 2020 in the University hospital in Berlin.
To summarise: we found that the numbers of the kit’s leaflet are reliable, reproducible, and published in full detail in the scientific literature. Hurray!
We also found that even the gold standard PCR is not able to detect all infected persons, it all depends on how much virus is present, and how the sample is obtained.
But all in all, the PCR test is clearly more accurate. Why would we want to use an antigen test then? To do the PCR test you need a lab with skilled people, equipment such as PCR devices and pipets, and time, as the process takes at least a few hours to complete. The advantage of an antigen test is to have a low-tech, faster alternative that can be self-administered. But that comes at a cost, because the antigen tests are less sensitive.
From the analysis, it is clear that the rapid Antigen tests need more virus present to reliably detect infection. It is ALSO clear that the test is highly specific, with less than 1% false positives. Note that a false positive rate of 1% still means that in a healthy population of 1000, 10 are falsely detected as having COVID-19.
Surprisingly, nasal swabs appear to give results that are comparable to those of nasopharyngeal swabs, while having not having the disadvantages of them (unpleasant, can only be performed by professional health worker).
So the antigen tests are less sensitive than PCR tests. But now comes the key insight: the persons that produce the largest amounts of virus get detected, irrespective of whether they have symptoms or not. To me, this seems like a “Unique Selling Point” of the rapid tests: the ability to rapidly detect the most contagious persons in a group, after which these persons can go into quarantine and help reduce spread.
Thanks to dr. Andreas Lindner for providing helpful feedback and pointing out flaws in my original blog post. This should not be seen as an endorsement of the conclusions of this post, and any remaining mistakes are all my own!
Head-to-head comparison of SARS-CoV-2 antigen-detecting rapid test with self-collected nasal swab versus professional-collected nasopharyngeal swab: Andreas K. Lindner, Olga Nikolai, Franka Kausch, Mia Wintel, Franziska Hommes, Maximilian Gertler, Lisa J. Krüger, Mary Gaeddert, Frank Tobian, Federica Lainati, Lisa Köppel, Joachim Seybold, Victor M. Corman, Christian Drosten, Jörg Hofmann, Jilian A. Sacks, Frank P. Mockenhaupt, Claudia M. Denkinger, European Respiratory Journal 2021 57: 2003961
Head-to-head comparison of SARS-CoV-2 antigen-detecting rapid test with professional-collected nasal versus nasopharyngeal swab: Andreas K. Lindner, Olga Nikolai, Chiara Rohardt, Susen Burock, Claudia Hülso, Alisa Bölke, Maximilian Gertler, Lisa J. Krüger, Mary Gaeddert, Frank Tobian, Federica Lainati, Joachim Seybold, Terry C. Jones, Jörg Hofmann, Jilian A. Sacks, Frank P. Mockenhaupt, Claudia M. Denkinger European Respiratory Journal 2021 57: 2004430
SARS-CoV-2 patient self-testing with an antigen-detecting rapid test: a head-to-head comparison with professional testing: Andreas K. Lindner, Olga Nikolai, Chiara Rohardt, Franka Kausch, Mia Wintel, Maximilian Gertler, Susen Burock, Merle Hörig, Julian Bernhard, Frank Tobian, Mary Gaeddert, Federica Lainati, Victor M. Corman, Terry C. Jones, Jilian A. Sacks, Joachim Seybold, Claudia M. Denkinger, Frank P. Mockenhaupt, under review, preprint on medrxiv.org
Variation in False-Negative Rate of Reverse Transcriptase Polymerase Chain Reaction–Based SARS-CoV-2 Tests by Time Since Exposure: Lauren M. Kucirka, Stephen A. Lauer, Oliver Laeyendecker, Denali Boon, Justin Lessler Link to paper
Clinical evaluation of the Roche/SD Biosensor rapid antigen test with symptomatic, non-hospitalized patients in a municipal health service drive-through testing site: Zsὁfia Iglὁi, Jans Velzing, Janko van Beek, David van de Vijver, Georgina Aron, Roel Ensing, KimberleyBenschop, Wanda Han, Timo Boelsums, Marion Koopmans, Corine Geurtsvankessel, Richard Molenkamp Link on medrxiv.org
Performance of Saliva, Oropharyngeal Swabs, and Nasal Swabs for SARS-CoV-2 Molecular Detection: a Systematic Review and Meta-analysis: Rose A. Lee, Joshua C. Herigona, Andrea Benedetti, Nira R. Pollock, Claudia M. Denkinger Link to paper
Self-collected compared with professional-collected swabbing in the diagnosis of influenza in symptomatic individuals: A meta-analysis and assessment of validity: Seaman et al 2019 Link to paper


NELL A film review by Mark R. Leeper Copyright 1994 Mark R. Leeper
Capsule: The familiar story of the feral child and civilization discovering each other is given a very polished and generally intelligent treatment by Michael Apted. Beautiful Smokey Mountain photography and some very good performances make the first two-thirds very watchable. The last third is disappointingly familiar. Rating: +2 (-4 to +4)
In the back woods of the Great Smokey Mountains of North Carolina an old hermit woman dies. When a policeman (played by Nick Searcy) and a doctor, Jerome Lovell (Liam Neeson) come to investigate and tidy up the loose ends, they find a loose end nobody knew about. The woman had a daughter Nell (Jodie Foster) who had lived virtually without human contact and who spoke a completely unintelligible language. Nell has been raised to fear people and her reaction to these invaders is pure panic. Lovell brings in a second doctor, Paula Olsen (Natasha Richardson), little realizing that he is sowing the seeds of a three- way battle for the fate of Nell. One faction will want her to remain in the wild, one will want to study her in an institution, and both will want to keep her out of the hands of the media who want to exploit her. Deep in the woods Lovell and Olsen competitively initiate studies to understand Nell and the forces that made her what she is, to decipher her language, and to ease her terror of strangers.
Michael Apted is singularly appropriate to direct NELL. Two of the major themes of his film are how Nell's childhood has molded her into the enigmatic woman that she is and how the outside world and mainstream society are a corrupting influence. Apted is the creator of the 7 UP, 7 PLUS 7, 21 UP, 28 UP, and 35 UP documentaries, which are released each seven years, examining at seven-year intervals the lives of 14 people and how they develop. He also directed GORILLAS IN THE MIST, THUNDERHEART, and the documentary INCIDENT AT OGLALA, each of which has a theme of the corruptive or exploitive influence of society on the innocent. Both themes are present in William Nicholson and Mark Handley's adaptation of Handley's stage play "Idioglossia." Nicholson, incidentally also wrote the screenplay for SHADOWLANDS. This story also looks at two approaches to science: one that tries to study in nature and one that prefers the laboratory approach, in vivo versus in vitro. In a violation of political correctness, unusual for Apted, the nurturing scientist, who sets up a pup tent and tries forming a relationship with Nell, is the man. The woman scientist's approach is to bring up a houseboat full of electronic equipment and to observe Nell with surveillance cameras.
The telling of the story is deliberate, like a scientific case study. For viewers who are not interested in the puzzle of understanding Nell's behavior and her language, the film will be as slow-paced as watching someone fill out a crossword puzzle or paint a picture. The writing requires at least a modicum of curiosity about the reasoning of anthropologists and how they do their work. Apted takes a good long time before he starts talking down to his audience and moving the story in what are, unfortunately, some very predictable directions.
As time goes by Nell and her language become more understandable. It is not entirely clear why this verbal fruit cocktail starts sounding more comprehensible. It is possible that the listener's ear becomes more attuned to the language or that the more Nell is around people the more she might start to imitate their speech patterns. I suspect, however, that the film is really a little less than honest by simply having Foster's language written closer to spoken English in the later parts of the film.
Foster's acting in dramatic scenes is nearly perfect, though her ecstatic, dance-like jaunts though nature seem a bit idealized. Neeson is compelling and sensitive. Probably he is typecast as being sensitive after playing Oskar Schindler. Richardson comes in a fair third for acting honors, but it is really Foster's movie. Also watchable is the photography of the Great Smokey Mountains, by Dante Spinotti. And though it lacks the breathtaking spectacle of his work for THE LAST OF THE MOHICANS, his eye for the beauty of nature becomes an intergal part of the film.
This is not so much an original film as a familiar story done very well. Certainly it ranks among one of Apted's better dramatic films. I give it a +2 on the -4 to +4 scale.
Mark R. Leeper<EMAIL_ADDRESS>.
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Write a function that returns the text and spacing of "The Red Wheelbarrow", a poem by William Carlos Williams.
Write a function called "longestWord" that takes 3 parameters. Given 3 words, "longestWord" returns which word is the longest.
var output = longestWord('tiger', 'duck', 'hippopotamous');
console.log(output); // "hippopotamous is the longest word."
Write a JavaScript for loop that will iterate from 0 to 15. For each iteration, it will check if the current number is odd or even, and display a message to the screen.
Sample Output :
"0 is even"
"1 is odd"
"2 is even"
var n = 0;
while (n <= 3) {
console.log("n is now " + n);
n++;
}
console.log(n);
//"n is now 0"
//"n is now 1"
//"n is now 2"
//"n is now 3"
var sum = 0;
for (var i = 1; i <= 50; i++) {
sum = sum + i;
}
alert("Sum = " + sum); // => Sum = 1275
In a for-loop, all three parts i.e. initializer, test condition, and updater are written together in a single line (called an iteration statement).
var n = 0;
while (n <= 3) {
console.log("n is now " + n);
n++;
}
//"n is now 0"
//"n is now 1"
//"n is now 2"
//"n is now 3"
for (var n = 0; n <= 3; n++) {
console.log("n is now " + n);
}
//"n is now 0"
//"n is now 1"
//"n is now 2"
//"n is now 3"
In general, you should use a for loop when you know how many times the loop should run. If you want the loop to break based on a condition other than the number of times it runs, you should use a while loop.


Check this box if you'd like Ameol to run the attached file after it has been decoded. This will be done by launching the application that is associated with this file type.


The difference between html and css is absolutely everything, they actually complement each other, I like to think that html is like a house without absolutely any type of 'finishing', a house as it is built, columns, beams, walls and roof, but then come CSS and I think of css as absolutely everything that styles that house, colour and texture on the walls, the type of floor that the house will have, the type of lamps, the texture, if it will have curtains or blinds... or both, which kind of taps and switches will it have... absolutely everything that we see that makes the house 'pritier' or 'stylish'. The same way I imagine that html and css work, together in order to display the website, html is the structure, the base and foundations of the website, while css is all the styling that we see in each website.
Control flow is the order in which a code is interpreted in order to execute it. It generally is line by line, unless it comes across an instruction to go look back again, which in this case would be a 'loop', to put it in an example: let's say that we are at the supermarket and we have a list of articles to buy, so we enter the supermarket and go and pick what we need, and we do so by walking one isle at a time, and when we reach the end and we check our list we find that we have everything that we need, then we go and proceed to the checkout; but if at that point, we don't have everything that we need, then in that case we go back to the isle where we need to get the article that we're missing. So the same way is the control flow and loops in javascript in our code; the variables are the objects in our list, the control flow is out path in order to get them and the loops when/if we need to go back to get the rest of the articles that we're missing.
D - document
O - object
M - model
The way that I understand it, the DOM is the magic that happens 'behind curtains' on a website, it usually is represented as a tree, with all the branches coming out from a single element, where every element is called a 'node', and each element has properties. Now the DOM, being considered an 'object oriented' it means that... as an analogy let's think of an car as a whole, if it would not be an object oriented and we want to make a change on the car, let it be the colour, or the seats or the engine, we would have to start from scratch again to design the whole car with the change that we want, but by being 'object oriented' we can work on every single 'object' that we want to change or modify. So if we want to change or modify any part of the car, we can grab that element and change or modify it without having to start the whole car from scratch. The same way an object oriented language works, we can modify every single one of the elements (or nodes) and their attributes, and the way that we can do that is through the DOM,. To put it other words, html sends informations to the DOM and on the other side there is a programming language like javascript which interacts with the DOM as an API for the html so the DOM grabs both html & (in this case) javascript, interprets both of them and what we end up looking on the screen is based on the DOM and not based on the html code.
We use 'objects' to represent a thing in our code. It can be anything,
a person, and actual object, a book, etc. anything that we want, so
like any object/person/year/book... they all have characteristics that
differentiate one from each other and these characteristics are known as
'properties' in javascript.
These properties can be either: access, added, changer or removed;
and the way that we do that is with a dot '.' or a bracket '[]'.
dot = object.property
bracket = object['property']
person.age and pergon['age'] both entries would return the age of 'person',
and so we can add, remove or change properties of an object.
We use 'arrays' when we want to create a list of different items in one variable.
It is important to mention that arrays have a zero base index, which means that
when accessing a list of items in an array, we will do with their position inside
the array, so for arrays, the number 0 is the first item on the list, therefore,
if we have 3 items and we want the first one of the list, that would be the number 0.
example:
var colours = ['red', 'blue', 'yellow', 'green'];
so if we want to call on the first item, we will do so by calling the number 0:
colour[0] (will return the colour 'red')
Just like properties in an object, the items inside an array can also be added, removed, change.
So the main difference when accessing data between objects and arrays is that when we call
the property of the object, we will do so calling directly this property, but in an array, by
being able to hold a large list of items, we can do so by number in their index.
Functions are used to perform specific tasks and it is what gives the
interactivity to our websites or apps, we also use it to perform certain
actions to help us to retrieve data. One of the best things about
functions is that with these we can write a more efficient code,
instead of writing the same piece of code over and over, we can
instead write a function that will save us from writing such piece of
code over and over, which ultimately will make our code easier to
read and easier to maintain.


João Graça is currently the CTO of Unbabel. João did his PhD in Natural Language Processing and Machine Learning at Instituto Superior Técnico together with the University of Pennsylvania with Professors Fernando Pereira, Ben Taskar and Luísa Coheur. He is the author of several papers in the area, his main research topics are machine learning with side information, unsupervised learning and machine translation. João is one of the co-founders of the Lisbon Machine Learning Summer School.


This block determines the hypotenuse y = sqrt(u1^2 +
u2^2)
if the boolean parameter u1IsHyotenuse =
false
. In this case the two inputs u1
and
u2
are interpreted as the legs of a right triangle and
the boolean output valid
is always equal to
true
.
If u1IsHyotenuse = true
, input u1
is
interpreted as hypotenuse and u2
is one of the two
legs of a right triangle. Then, the other of the two legs of the
right triangle is the output, determined by y = sqrt(u1^2 -
u2^2)
, if u1^2 - u2^2 ≥ 0
; in this case the
boolean output valid
is equal to true
. In
case of u1^2 - u2^2 < 0
, the output y =
0
and valid
is set to false
.


Abhishek Bachchan to lead SRK's next production 'Bob Biswas'
It is not confirmed if "Bob Biswas" is a spin-off of the character in Sujoy Ghosh's 2012 thriller "Kahaani" though Sujoy is associated with both the films.
MUMBAI: Superstar Shah Rukh Khan on Monday announced his next production, "Bob Biswas", featuring Abhishek Bachchan in the lead.
The actor, who is co-producing the project through Red Chillies Entertainment with director Sujoy Ghosh's Bound Script Production, took to Twitter to share the news.
Bob Biswas was a breakout character in Sujoy Ghosh's 2012 thriller "Kahaani".
Played by actor Saswata Chatterjee, Biswas was an LIC agent who moonlighted as a cold-blooded contract killer.
However, it is not confirmed if "Bob Biswas" is a spin-off of the character though Sujoy is associated with both the films.
Diya Annapurna Ghosh will direct the new project.
Red Chillies announced the project, writing, "Nomoshkar", a hat-tip to Biswas' catchphrase, "Nomoshkar, ek minute," which he used before killing his target.
Abhishek said he is looking forward to working in the film.
Sujoy said he needs "blessings and good wishes" for the film, adding, "And a minute of your time."


To see callbacks being logged, open your browser's console.
In case of error, the image is set to a fallback image generated by placehold.it


How To Advance Your Trace Element Analysis in Environmental Samples
by James HannanWho's speaking at this Webinar?
Accurate and precise measurement of major, minor and trace elements in samples from environmental sources is a key requirement across the world. Samples such as surface waters, potable waters and soils must meet the concentration limits specified in a range of legislative standards, such as EPA Methods 6010, 6020, 200.7 and 200.8 and the European Water Framework Directive.
In this webinar, you will discover how the latest ICP-OES and ICP-MS instruments and software from Thermo Scientific meet and exceed analysis standards for different environmental sample types.
In this webinar you will learn about:
- Environmental analysis legislation
- Which trace elemental analysis instruments are best suited to different environmental measurements
- Analysis performance for selected environmental applications


Landing Page
Special Projects
This story is part of a series of specially designed stories that represents some of the best journalism The Post has to offer. Check out the rest of the special projects here.
MEAGAN HALL
08.24.17
Ohio will enter its 20th season of play at Chessa Field with the goal of pulling out close games.
Last season the Bobcats went a disappointing 5-12-1, but nine of those losses came by just one goal, and six of those losses came in overtime. The young Bobcats proved in those close losses they had the ability to play with some tough competition.
Ohio’s close contests last year can be contributed to the combined excellence in the net by Taylor Smith, Erin Beurket and Vanessa Cordoba. All three shared playing time throughout the 2016 season. Smith played in four games and recorded 13 saves and Cordoba appeared in three games and recorded 17 saves. Beurket received the majority of the starts, recording 63 saves in 12 games.
All three goalies will look to carry that momentum from impressive seasons last year into a season where they will face many familiar strikers — Ohio’s schedule this season contains 17 of the 18 teams the Bobcats faced last season.
Matt Starkey | FILE
Mandy Arnzen (6) battles for the ball agaisnt Western Michigan at Chessa Field on September 30th, 2016.
Ohio’s offense will also be helped by the familiar schedule as the Bobcats will return 11 of the 12 players that scored a goal last season, including Bryce Hueber and Alivia Milesky, who tied for the team lead with four goals each.
Backing up Hueber and Milesky in the offensive attack will be Sydney Leckie and Allie Curry. Curry scored three goals and two assists in her junior year in 2016. Leckie scored two goals in her freshman season and led the team with four assists in 2016.
Coach Aaron Rodgers hopes the experienced 2017 squad, which only lost five players from 2016, can return Ohio to the Mid-American Conference Tournament. The Bobcats have not reached the MAC Tournament since Rodgers’ first season at the helm in 2013.
But Rodgers program returning to the MAC Tournament for the first time in three seasons will have its challenges — including losing Alexis Milesky, who scored 17 goals throughout her four-year career and was a constant force on the pitch due to her aggressive play.
Another challenge for Ohio in 2017 is a Sept. 10 showdown with the University of Kentucky. The Wildcats are the only team on the 2017 schedule that the Bobcats did not play in 2016.
That will be the first time the Bobcats will face a Southeastern Conference team since they traveled to Kentucky in 2015. The Wildcats won that game 3-0.
The game at Chessa Field in September will be the seventh meeting all-time between Ohio and Kentucky, but just the second game to be played in Athens. It will also be the first time an SEC program has played in Athens since Ohio softball hosted a doubleheader with Kentucky softball in 2016.
The weekend of Sept. 22-24 will be the 20th season celebration. Alumni events will be take place throughout the weekend, and Ohio will host Eastern Michigan that Friday, followed by Central Michigan that Sunday, in two showdown MAC games.
BackLanding Page
This story is part of a series of specially designed stories that represents some of the best journalism The Post has to offer. Check out the rest of the special projects here.


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Packages that use org.jredis.connector | |
|---|---|
| org.jredis | This package contains the constructs that define the Java API semantics of the JRedis clients. |
| org.jredis.connector | Native Client Interface Specification. |
| org.jredis.ri.alphazero | This package and child packages contain reference implementation alphazero
of the JRedis and Connection
of the optional Connector specifications. |
| Classes in org.jredis.connector used by org.jredis | |
|---|---|
| ProviderException
Used by JRedis implementation providers to indicate an exception related to the implementation of the specification. |
| Classes in org.jredis.connector used by org.jredis.connector | |
|---|---|
| Connection
|
|
| Connection.Modality
Enum for defining the operational modality of the protocol handlers. |
|
| ConnectionSpec
Connection specification for getting (creating) Connection objects. |
|
| ConnectionSpec.SocketFlag
Flag keys for SocketFlag settings of the connection specification. |
|
| ConnectionSpec.SocketProperty
Property keys for SocketProperty settings of the connection specification. |
|
| Message
[TODO: document me!] |
|
| Protocol
Protocol is effectively a Message factory. |
|
| ProviderException
Used by JRedis implementation providers to indicate an exception related to the implementation of the specification. |
|
| Request
[TODO: document me!] |
|
| RequestListener
|
|
| Response
[TODO: detail the requirements - this is wip.] |
|
| Response.Type
A redis server responds with: Status response - such as Command.SET
Value Data ("String") - such as Command.GET
Bulk Data - such as Command.KEYS
Multi Bulk Data - such as Command.LRANGE
|
|
| ResponseStatus
[TODO: document me!] |
|
| ResponseStatus.Code
Status code enum -- error or ok |
| Classes in org.jredis.connector used by org.jredis.ri.alphazero | |
|---|---|
| BulkResponse
[TODO: document me!] |
|
| Connection
|
|
| Connection.Modality
Enum for defining the operational modality of the protocol handlers. |
|
| Message
[TODO: document me!] |
|
| MultiBulkResponse
[TODO: document me!] An object implementing this interface will return Response.Type.MultiBulk to the Response.getType()
method |
|
| Protocol
Protocol is effectively a Message factory. |
|
| ProtocolFactory
[TODO: document me!] |
|
| ProviderException
Used by JRedis implementation providers to indicate an exception related to the implementation of the specification. |
|
| Request
[TODO: document me!] |
|
| RequestListener
|
|
| Response
[TODO: detail the requirements - this is wip.] |
|
| Response.Type
A redis server responds with: Status response - such as Command.SET
Value Data ("String") - such as Command.GET
Bulk Data - such as Command.KEYS
Multi Bulk Data - such as Command.LRANGE
|
|
| ResponseStatus
[TODO: document me!] |
|
| StatusResponse
This is just a marker interface. |
|
| ValueResponse
Formally, redis only returns "integers" as values, but in fact, an operation such as Command.RANDOMKEY will return a key in a single line reply, and not a bulk reply. |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


I've recently started monitoring my new SharePoint 2010 farms on SCOM, and found the management pack's documentation to be rather lacking in setup instructions, and the required permissions for SCOM's account on the farm were rather shocking:
- Local admin on all SharePoint servers
- Local admin on all SQL servers
- dbowner on all SharePoint's databases
- Membership in the Farm Administrators group
After some experimenting, I managed to reduce the permissions to a
normal level, and create my own (working!) workflow:
(treat FARM as a unique identifier for your farm)
-
Prepare a special AD account (one for every farm) for SCOM's monitoring, such as
SCOM-Sharepoint-FARM
. -
Grant that account:
- Membership in the
Farm Administrators
group on the SharePoint farm (via Central Administration) dbowner
on the farm's DBs (orsysadmin
on the SQL server, if it only holds this farm's DBs anyway)
- Membership in the
-
Using SCOM's console, Create a Windows
Run-As account
(under administration, be careful) named something like "SP FARM Monitoring" -
Edit the SharePoint MP's xml file thusly:
- If you installed the MP on the SCOM server (as you should), copy the
"SharePointMP.Config" file from
C:\Program Files (x86)\System Center Management Packs\Microsoft SharePoint 2010 Products OpsMgr 2007 MP en-us\
toC:\Program Files\System Center Management Packs\
. It should stay there. - Open the file in your favorite XML editor
-
Add an Association node like:
<Association Account="NAME" Type="Agent"></Association>
Where
NAME
is SCOM's Run-As account -
Inside the Association node, add a Machine node for every computer inside the farm, like:
<Machine Name="MACHINE" />
- If you installed the MP on the SCOM server (as you should), copy the
"SharePointMP.Config" file from
-
Add every SharePoint server to SCOM's monitored servers (through discovery wizard)
-
Execute the task
Configure SharePoint Management Pack
(inMonitoring > SharePoint 2010 Products > Administration
). Change the task credentials to an account with farm administrator privileges (like yours), otherwise the task will execute with SCOM's default action account, which might not have enough permissions. -
Wait for about an hour, and check out the Diagram View!
If your servers won't appear, check the unidentified machines
view,
the Agent's health, and the server's event log.


|
Yatta
1.6.9
Library for compressing and diffing buffers and files.
|
Classes | |
| struct | VirtualFile |
Public Member Functions | |
| ~Directory () | |
| Destroy this virtual directory. More... | |
| Directory (const std::string &path, const std::vector< std::string > &exclusions=std::vector< std::string >()) | |
| Constructs a virtual directory from a path on disk. More... | |
| Directory (const Buffer &package, const std::string &path, const std::vector< std::string > &exclusions=std::vector< std::string >()) | |
| Constructs a virtual directory directly from a package buffer. More... | |
| Directory (const Directory &other) | |
| Copy Constructor. More... | |
| Directory (Directory &&other) noexcept | |
| Move Constructor. More... | |
| Directory & | operator= (const Directory &other) noexcept |
| Copy-assignment operator. More... | |
| Directory & | operator= (Directory &&other) noexcept |
| Move-assignment operator. More... | |
| std::optional< Buffer > | make_package () const |
| Compresses all data found within this directory into an .npack - package formatted buffer. More... | |
| bool | apply_folder () const |
| Writes this virtual directory's contents to disk. More... | |
| std::optional< Buffer > | make_delta (const Directory &newDirectory) const |
| Compares this directory against another, generating a .ndiff - delta formatted buffer, for transforming this into the new directory. More... | |
| bool | apply_delta (const Buffer &diffBuffer) |
| Executes the instructions contained within a .ndiff - delta formatted buffer upon this directory. More... | |
| size_t | fileCount () const |
| Retrieve the number of files in this directory. More... | |
| size_t | byteCount () const |
| Calculates the number of bytes this directory uses. More... | |
| Directory (const std::filesystem::path &path, const std::vector< std::string > &exclusions={}) | |
| Constructs a virtualized directory from a path on disk. More... | |
| Directory (const Directory &other)=default | |
| Directory (Directory &&other) noexcept=default | |
| void | in_folder (const std::filesystem::path &path, const std::vector< std::string > &exclusions={}) |
| void | out_folder (const std::filesystem::path &path) |
| bool | empty () const noexcept |
| Check if this directory is empty - has no files. More... | |
| bool | hasFiles () const noexcept |
| Retrieves whether or not this directory has files. More... | |
| size_t | fileCount () const noexcept |
| Returns the number of files in this directory. More... | |
| size_t | fileSize () const noexcept |
| Returns the sum of all file sizes in this directory. More... | |
Static Public Member Functions | |
| static std::string | GetStartMenuPath () |
| Retrieves the path to the user's start-menu folder. More... | |
| static std::string | GetDesktopPath () |
| Retrieve the path to the user's desktop. More... | |
| static std::string | GetRunningDirectory () |
| Retrieve the directory this executable is running from. More... | |
| static std::string | SanitizePath (const std::string &path) |
| Cleans up the target string representing a file path, specifically targeting the number of slashes. More... | |
| static std::string | GetRunningDirectory () noexcept |
Protected Attributes | |
| std::vector< VirtualFile > | m_files |
| std::string | m_name = "" |
| Directory::~Directory | ( | ) |
Destroy this virtual directory.
|
explicit |
Constructs a virtual directory from a path on disk.
If the path is to a folder, the folder is immediately virtualized. If the path is to a .npack file, the package is read and virtualized. If the path is to an application with an embedded .npack resource, the application is mounted then the package is read and virtualized.
| path | the absolute path to a desired folder or a package file. |
| exclusions | (optional) list of filenames/types to skip. "string" matches relative path, ".ext" matches extension. |
| Directory::Directory | ( | const Buffer & | package, |
| const std::string & | path, | ||
| const std::vector< std::string > & | exclusions = std::vector<std::string>() |
||
| ) |
Constructs a virtual directory directly from a package buffer.
| package | the package buffer to unpack and virtualize. |
| path | the absolute path to a desired folder or a package file. |
| exclusions | (optional) list of filenames/types to skip. "string" matches relative path, ".ext" matches extension. |
| Directory::Directory | ( | const Directory & | other | ) |
Copy Constructor.
| other | the directory to copy from. |
|
noexcept |
Move Constructor.
| other | the directory to move from and invalidate. |
|
explicit |
Constructs a virtualized directory from a path on disk.
| path | the absolute path to a desired folder or a package file. |
| exclusions | (optional) list of filenames/types to skip. "string" matches relative path, ".ext" matches extension. |
| bool Directory::apply_delta | ( | const Buffer & | diffBuffer | ) |
Executes the instructions contained within a .ndiff - delta formatted buffer upon this directory.
| diffBuffer | the buffer containing the compressed diff instructions. |
| bool Directory::apply_folder | ( | ) | const |
Writes this virtual directory's contents to disk.
| size_t Directory::byteCount | ( | ) | const |
Calculates the number of bytes this directory uses.
|
noexcept |
Check if this directory is empty - has no files.
|
noexcept |
Returns the number of files in this directory.
|
noexcept |
Retrieve the number of files in this directory.
|
noexcept |
Returns the sum of all file sizes in this directory.
|
static |
Retrieve the path to the user's desktop.
|
staticnoexcept |
Retrieve the directory this executable is running from.
|
static |
Retrieves the path to the user's start-menu folder.
|
noexcept |
Retrieves whether or not this directory has files.
Compares this directory against another, generating a .ndiff - delta formatted buffer, for transforming this into the new directory.
| newDirectory | the newer directory to compare against. |
| std::optional< Buffer > Directory::make_package | ( | ) | const |
Compresses all data found within this directory into an .npack - package formatted buffer.
Copy-assignment operator.
| other | the buffer to copy from. |
Move-assignment operator.
| other | the buffer to move from. |
|
static |
Cleans up the target string representing a file path, specifically targeting the number of slashes.
| path | the path to be sanitized. |


Show Each Field (Top 100), Sort by Time, No Filter
Show Field Subset (Top 100), Sort by ID, Filter on ID
Aggregate on Count of Network, Filter on Network
Aggregate on Count of Day, Filter on Day
Aggregate on Count of Network / Lon / Lat (Top 100), Filter on Network and Lon / Lat Point


%- include("./components/root/seo.html"); %>
<%- include("./components/root/globals.html"); %>
<%- include("./components/home/header.html"); %>
a new way to create.
a new way to play.
welcome to cluster.
🎮 find your favorite games
[gotta put a game card in here]
🎧 vibe to the max
[gotta put a music card in here]


This is your SAP BTP Cloud Foundry Spring application powered by the SAP Cloud SDK.
application/
directory and execute
mvn spring-boot:run
.
application/src/main/java/
.
application/src/main/resources/static/
.
Further help and examples are available here.


Chelsea Football Club are an English professional football club based in Fulham, London. Founded in 1905, they compete in the Premier League, the top division of English football. Chelsea are among England's most successful clubs; they have been league champions six times, and won over thirty competitive honours - including six European trophies. Their home ground is Stamford Bridge.
Chelsea won their first major honour, the League Championship, in 1955. They won the FA Cup for the first time in 1970 and their first European honour, the UEFA Cup Winners' Cup, in 1971. After a period of decline in the late 1970s and 1980s, the club enjoyed a revival in the 1990s and had more success in cup competitions. The past two decades have been the most successful in Chelsea's history: they won five of their six league titles and the UEFA Champions League during this period. Chelsea are one of five clubs to have won all three of UEFA's main club competitions, and the only London club to have won the Champions League.
Chelsea's home kit colours are royal blue shirts and shorts with white socks. The club's crest features a ceremonial lion rampant regardant holding a staff. The club have rivalries with neighbouring teams Arsenal and Tottenham Hotspur, and a historic rivalry with Leeds United. Based on attendance figures, the club have the sixth-largest fanbase in England. In terms of club value, Chelsea are the sixth most valuable football club in the world, worth £2.13 billion ($2.576 billion), and are the eighth highest-earning football club in the world, with earnings of over €428 million in the 2017–18 season. Since 2003, Chelsea have been owned by Russian billionaire Roman Abramovich.


Founder and CEO of ICEBERG❄
IceBerg is a world leader in cloud based services and blockchain solutions providing answers to some of the world's greatest problems


A very basic RSS reader webpage. POC right now
And the name is a play on "feature creep". I'm waiting for inspiration to offer a better one


| Package | com.developmentarc.core.utils.events |
| Class | public class LocalConnectionEvent |
| Inheritance | LocalConnectionEvent flash.events.Event |
| Property | Defined by | ||
|---|---|---|---|
| errorID : int
Stores the error ID if provided.
| LocalConnectionEvent | ||
| errorMessage : String
Contains the error message that has been generated or received.
| LocalConnectionEvent | ||
| status : String
Contains the simple status string.
| LocalConnectionEvent | ||
| statusCode : String
Contains the status code for a status message.
| LocalConnectionEvent | ||
| statusMessage : String
Stores the sting verison of the status message that contains the instance name that reported the error.
| LocalConnectionEvent |
| Method | Defined by | ||
|---|---|---|---|
|
LocalConnectionEvent(type:String, bubbles:Boolean = false, cancelable:Boolean = false)
Constructor.
| LocalConnectionEvent |
| Constant | Defined by | ||
|---|---|---|---|
| CONNECTION_ERROR : String = "CONNECTION_ERROR" [static]
Dispatched when the LocalConnectionManager can not connect to the requested application name.
| LocalConnectionEvent | ||
| SENT_MESSAGE_ERROR : String = "SENT_MESSAGE_ERROR" [static]
When a message can not be sent properly by the LocalConnectionManager this error is dispatched.
| LocalConnectionEvent | ||
| STATUS_MESSAGE : String = "STATUS_MESSAGE" [static]
Dispatched when a status message has been sent.
| LocalConnectionEvent |
| errorID | property |
public var errorID:int
Stores the error ID if provided.
| errorMessage | property |
public var errorMessage:String
Contains the error message that has been generated or received.
| status | property |
public var status:String
Contains the simple status string.
| statusCode | property |
public var statusCode:String
Contains the status code for a status message.
| statusMessage | property |
public var statusMessage:String
Stores the sting verison of the status message that contains the instance name that reported the error.
| LocalConnectionEvent | () | constructor |
public function LocalConnectionEvent(type:String, bubbles:Boolean = false, cancelable:Boolean = false)
Constructor. Same as the base Event Class.
Parameterstype:String — The Event Type
|
|
bubbles:Boolean (default = false ) — Defines if the event should bubble.
|
|
cancelable:Boolean (default = false ) — Defines if the event can be cancelled.
|
| CONNECTION_ERROR | constant |
public static const CONNECTION_ERROR:String = "CONNECTION_ERROR"
Dispatched when the LocalConnectionManager can not connect to the requested application name. This is usually caused by another application already connected via the provided name.
| SENT_MESSAGE_ERROR | constant |
public static const SENT_MESSAGE_ERROR:String = "SENT_MESSAGE_ERROR"
When a message can not be sent properly by the LocalConnectionManager this error is dispatched. If the error is caused by a callback from another application using the LCM protocol then the event will contain details about the cause of the error.
| STATUS_MESSAGE | constant |
public static const STATUS_MESSAGE:String = "STATUS_MESSAGE"
Dispatched when a status message has been sent.


(cancelButton)
(change Msg Env Exe Exe)
(gui '(+UndoButton))
(gui '(+RedoButton))
...
(gui '(+Button) "Do something"
'(change "Some change action"
(env 'New (makeNewValue) 'Old (getCurrentValue)) # Build environment
(restoreValue Old) # Undo-expression
(doSomething New) ) ) # Do-expression
When this button is pressed, 'doSomething' is executed with the results of (makeNewValue) and (getCurrentValue). The tooltip of the undo-button will show "Undo: 'Some change action'". The redo-stack is cleared and the redo-button is disabled.
If now the undo-button is pressed, 'undoSomething' is executed with the saved results of (foo) and (bar). It should perform the opposite action of 'doSomething', effectively undoing the operation. The tooltip of the redo-button will now show "Redo: 'Some change action'", and the tooltip of the undo-button will show a possible previous undoable operation. Pressing the redo-button will *do* the operation again, and so on.
See also +UndoButton, +RedoButton.(choButton 'Exe)
(chart @)
(chart) # chart
(chart 'data 1) # The first line (list) of the chart's data.
+Chg
+ChoButton
(choButton 'Exe)
. +ChoButton
is quite a general class. It can be used to select, or even do, anything.
See also choButton, +Tiny, +Tip, +Button.
+Choice
+ChoButton
. Opens a dialog
that allows the user to choose anything from a list, which is dynamically generated from the 'Exe' argument.
See also +ChoButton, dialog.
(cho)
cho
is a function that returns the number 16 if the diaform
is used as a normal form (i.e. not as a dialog) or 8 if used in another context. It is typically used to show a different number of rows in a chart when the same chart is used as a dialog compared to when it is used on it's own. The following code fragment comes from the demo app included in the PicoLisp distribution, in gui.l. Here we can see cho
being used to determine how many rows of data should be created, as well as making sure scrolling the data goes along with the number of rows.
.
.
(do (cho)
( (alternating)
(gui 1 '(+DstButton) Dst)
(gui 2 '(+NumField))
(gui 3 '(+ObjView +TextField) '(: nm))
(gui 4 '(+TextField))
(gui 5 '(+MailField))
(gui 6 '(+TextField))
(gui 7 '(+TextField))
(gui 8 '(+TelField))
(gui 9 '(+TelField)) ) ) )
(
(scroll (cho))
.
.
See also diaform.
(choTtl Ttl X . @)
choTtl
is a utility function typically used to set the title of a chart in a search dialog. The function combines a transient symbol, a text string, with the number of objects of a given type in the database. Here is an example from the demo app included in the PicoLisp distribution, in gui.l
(choTtl ,"Customers/Suppliers" 'nr '+CuSu)
This example specifies an index, "...'nr '+CuSu)", and counts the number of +CuSu
objects in that index. The result is combined with "Customers/Suppliers", setting the title of the data chart to, for example, "3 Customers/Suppliers". It is also possible to specify only the class, "... '+CuSu)". In that case the total number of entities of that class is used, regardless of any index.
(choDlg Dst Ttl Rel [Hook] [((+XyzField) ..) Exe Able])
choDlg
, "choose dialog" creates a dialog that lets the user select or create an object, to be either jumped to (when called as a form), or taken into the destination field (when called as a dialog, see +DstButton) The following example comes from the demo app included with the PicoLisp distribution, in cusu.l. This file implements a form that handles objects of a class called +CuSu
, "CustomerSupplier". +CuSu
is connected to another class, +Sal
, "Salutation". Using a choDlg
in cusu.l allows a user to add or change the salutation belonging to the current object from the same GUI page used to edit other properties.
,"Salutation" (choDlg 0 ,"Salutations" '(nm +Sal))
This code creates a choDlg
that presents objects of the class +Sal
using a diaform
. Selecting an object in the choose dialog will close the dialog and adopts the selected value as the new salutation.
See also diaform.
+Close
+Clr0
+Click
+Auto
to automatically click a button after a certain amount of time has passed. Strictly speaking, +Click
is not limited to +Auto
buttons, but that is the most common usage.
(gui '(+Click +Auto +Button) 420 'This 1000 '(pop *Throbber)
'(with (: home)
(for Col (: grid)
(for This Col
(let N # Count neighbors
(cnt
'((Dir) (get (Dir This) 'life))
(quote
west east south north
((X) (south (west X)))
((X) (north (west X)))
((X) (south (east X)))
((X) (north (east X))) ) )
(=: next # Next generation
(if (: life)
(>= 3 N 2)
(= N 3) ) ) ) ) )
(for Col (: grid) # Update
(for This Col
(=: life (: next)) ) ) ) )
See also +Auto, +Button.
+Chk
+Chk
in combination with the built-in validation from +NumField
to only accept numbers not bigger than 9.
(app)
(action
(html 0 "+Chk"<EMAIL_ADDRESS>NIL
(form NIL
(gui '(+Chk +NumField)
'(or
(extra)
(and (> (val> This) 9) "Number too big") )
12 )
(gui '(+JS +Button) "Print"
'(msg (val> (field -1))) ) ) ) )
+Chart
+Chart
is a number:
(gui (+Chart) 2)
(<table> NIL NIL '((NIL "Text") (NIL "Number"))
(do 4
(<row> NIL
(gui 1 '(+TextField) 20)
(gui 2 '(+NumField) 10) ) ) )
This number tells the chart how many columns of data to expect. As can be seen in the code
snippet above, the number '2' matches the number of gui components in the table. To make it
possible for a +Chart
to display data in a representation that is different from how
the date is stored, you may pass two functions to a +Chart
.
The functions in question are a 'put' and a 'get' function, and they are responsible for
'translating' the data format between the gui and the internal representation.
The first function is a 'put'- function that puts data into the GUI components from the
internal representation and the second one is a 'get'- function gets data from the GUI
components into the internal representation.
(gui '(+E/R +Chart) '(bin : home obj) 3
'((This) (list (: nm))) # 'Put'- function
'((L D) # 'Get'- function
(and D (put!> D 'nm (car L)))
D ) )
(<table> NIL "Binaries" '((NIL "Name"))
(do 6
(<row> NIL
(gui 1 '(+Able +TextField) '(curr) 30)
(gui 2 '(+DelRowButton))
(gui 3 '(+BubbleButton)) ) ) )
All GUI components that follow a chart and that have a number as their first
argument go into that chart. Typically, the components are arranged in a
<table>
but this is not a requirement. Any suitable
layout works just as well.
See also charts, +Chart1,
+QueryChart and gui.
+Chart1
(gui '(+Var +Chart1) (: mup -3) 3)
(<table> 'chart NIL '((NIL "Media"))
(do 3
(<row> (alternating)
(gui 1 '(+ObjView +TextField) '(: nm)) # Binary name
(gui 2 '(+DelRowButton))
(gui 3 '(+BubbleButton)) ) )
(<row> NIL (scroll 3 T)) )
The example above comes from the code running the PicoLisp wiki, in
gui.l. In this code, a +Chart1
handles the data provided by
(: mup -3)
and the chart expects 3 columns. 'mup' is setup
a little earlier in the code:
(=: mup
(list
(and (: obj mup) (in (blob @ 'txt) (till NIL T))) # txt
NIL # sum
NIL # min
(: obj mup bin) ) )
'mup' is a list here, and (: mup -3)
picks (: obj mup
bin)
from there. 'list' is applied as the 'put'- function,
resulting in a list containing what is stored in the 'bin' property of
the markup contained in the current object. In the table displaying the
data, a combination of +ObjView and +TextField is used to create a link
to the object: (gui 1 '(+ObjView +TextField) '(: nm))
See also +Chart, charts.
+Checkbox
,"Hotel?" (gui '(+E/R +Checkbox) '(htl : home obj))
+Checkbox maps to a bool (T or NIL). In the example above, the 'htl' property of the current
object will contain T or NIL, depending on whether the checkbox in the gui has been ticked or not.
See also gui, +field
and input fields.
+ClassField
+ClassField
is used to display and change the class of an object.
(gui '(+ClassField) '(: home obj) '(("Male" +Man) ("Female" +Woman)))
The example above displays and changes a person's sex from male to female and vice versa.
See also +Map, +TextField.
cloneButton
clone>
- method (inherited from +Entity
). See also +Rid, +Able, +Tip and +Button.
(closeButton Lbl 'Exe)
+ClrButton
+Cue
(gui '(+Cue +TextField) "Please enter some text here" 30)
Causes an empty field to display "<Please enter some text here>"
(curr @)
.
.
(<table> 'chart NIL
'((NIL ,"File") (NIL ,"Delete"))
(do 2
( NIL
(gui 1 '(+DocObj +TextField) (curr)) #
(gui 2 '(+DelRowButton)) ) ) )
.
.


Control your Dialog IoT Sensor using JavaScript. This application demonstrates the functionality of the DA14583 IoT Sensor. The Dialog IoT Sensor provides the means to gather and process sensor data among six different sensors.
The data is gathered by the DA14583, processed and transferred over Bluetooth Low Energy to the application running on the smartphone.
Using the ‘Scan’ button the application scans for Bluetooth devices in the area. Once a device is found, the name and RSSI value of the device and a connect button is shown. After a certain period the app stops scanning to save the phone’s battery.
Once the phone is connected to the sensor a list of available sensors is shown. Clicking one of the sensors opens a graphical view as seen below. Data is automatically updated every time new sensor data is available.
Via the settings menu the sensor can be configured. The settings menu is split up in three parts: sensor configuration, calibration and sensor fusion settings. Changes in the settings are automatically stored in the sensor and can also be stored in flash memory. A ‘Reset to default’ button restores all settings of the sensor to default.
This example uses a high-level JavaScript library for communicating with the Dialog IoT Sensor. See the IoT Sensor Starter Guide to build your own app using the library!
You can browse the source code for this example at the Evothings GitHub repository.
The file index.html is the main HTML file of the app. You can find custom CSS in app.css
In the js folder you will find all JavaScript code required for the app.
The directory DA14583 contains the binaries for the Dialog IoT Sensor. You can also find these files on Dialog’s customer support site. You must use the SFL firmware for this app to function!
This example works with an Dialog IoT Sensor. Visit dialog-semiconductor.com for further details.
You can order your own IoT Sensor via Digi-Key or Mouser. For other distributors, visit the website.
Using Dialog’s SmartSnippets Bluetooth software platform you can store the image file to flash memory of the device. The SmartSnippets software can be found on Dialog’s customer support site (registration required).
Run the app in Evothings Viewer on Android or iOS.
An iOS device (7+) or an Android device with support for Bluetooth 4.0 (which includes BLE) is required. For Android, version 4.3 or later is needed.
Follow these steps to get started with this example:


In this example of Custom Element BarGauge, the user controls the proportion between Red, Green and Blue.
Red
Green
Blue


File Functionality
File : SocietiesPhoneGapTest.txt
Create File
File exists?
Display File
Write to File
Delete File
File System:
File Exists:
File Contents:
Error:
Back to main


I have been playing around with Haskell for the past week and have found it extremely interesting albeit a little frustrating. I started off with the wrong example. I have started learning every single language by starting off with the customary 'hello world' program. But in case of Haskell, that is the wrong way to start. Trust me!!
The program itself is a single line. But you will have to wrap your heads around a concept from Category Theory called a Monad.
Code for HelloWorld.hs


About page
MEMES
Multi page app!
Welcome to the first multi page app that I have made.
Here we will discuss what the app does
About
Da memes


Okay im having troubles. Maybe a bug?
Posted: Tue Aug 26, 2008 4:36 pm
Some poeple in game are saying it too, all i can see is the ground and Text. i cant see any models. =\ is there a fix? the very first time i ran it today i was able to see fine. but some people apeared to be blue lol, idk.
and is there a different bvoard to post bugs? im not sure of it. i didint see it. lol
and is there a different bvoard to post bugs? im not sure of it. i didint see it. lol


We visualize dogs!
- strategize value-added models
- syndicate sexy synergies
- monetize vertical initiatives
- exploit web-enabled deliverables
- brand transparent e-commerce
- revolutionize holistic e-markets
- target cross-media eyeballs
- reinvent bleeding-edge applications
- streamline mission-critical communities
- incentivize robust markets
- streamline wireless models
- e-enable best-of-breed web-readiness
- harness sexy systems


| Class | Description |
|---|---|
| Assert |
Quick null check assert class.
|
| Callbacks |
Internal callback interfaces that are passed into libwlc jna accessor.
|
| Compositor |
Compositor related events.
|
| Event |
Timed events and FD events are represented by this class.
|
| JWLC |
Wrapper access class for some useful global state function calls.
|
| Keyboard |
libwlc keyboard related functions/callbacks
|
| Mouse |
Pointer related functions are grouped here.
|
| Resource |
Abstract wrapper to wlc_resource.
|
| Resource.Textures |
Output from getTextures, contains format and actual texture numbers.
|
| Utils |
Internal utilities.
|


GO-CAMs are produced by members of the Gene Ontology Consortium (GOC). The GOC integrates gene descriptions from more than 35 research groups, from model organisms to protein databases.


acts_as_geocodable is a Rails plugin that makes your applications geo-aware. A picture (er, example) is worth a thousand words:
Examples
event = Event.create :street => "777 NE Martin Luther King, Jr. Blvd.",
:locality => "Portland", :region => "Oregon", :postal_code => 97232
# how far am I from RailsConf 2007?
event.distance_to "49423" #=> 1807.66560483205
# Find our new event, and any other ones in the area
Event.find(:all, :within => 50, :origin => "97232")
# Find the nearest restaurant with beer
Restaurant.find(:nearest, :origin => event, :conditions => 'beer = true')
See the API documentation for more details.
IP-based geocoding
acts_as_geocodable adds a remote_location
method to your Rails controllers for retrieving a user's location based on their remote IP address.
@nearest_store = Store.find(:nearest, :origin => remote_location) if remote_location
Don't rely too heavily on remote_location because the location of many IP addresses cannot be determined through HostIP.
Installation
Install the plugin by executing:
script/plugin install -x http://source.collectiveidea.com/public/rails/plugins/acts_as_geocodable
Contributing
Contributions are welcome and appreciated! Grab the source from:
http://source.collectiveidea.com/public/rails/plugins/acts_as_geocodable


Pay with TommyPay!
A very primitive payment app that shows the entire payment request passed to it as JSON.
Pay


Class SelectedMethod
Objects of this type are the return value from SelectMethods(IBuilderContext, IPolicyList). It encapsulates the desired System.Reflection.MethodInfo with the string keys needed to look up the IDependencyResolverPolicy for each parameter.
Inherited Members
System.Object.Equals(System.Object)
System.Object.Equals(System.Object, System.Object)
System.Object.GetHashCode()
System.Object.GetType()
System.Object.MemberwiseClone()
System.Object.ReferenceEquals(System.Object, System.Object)
System.Object.ToString()
Namespace: Unity.Builder.Selection
Assembly: Unity.Abstractions.dll
Syntax
public class SelectedMethod : SelectedMemberWithParameters<MethodInfo>
Constructors
| Improve this Doc View SourceSelectedMethod(MethodInfo)
Create a new SelectedMethod instance which contains the given method.
Declaration
public SelectedMethod(MethodInfo method)
Parameters
| Type | Name | Description |
|---|---|---|
| System.Reflection.MethodInfo | method | The method |
Properties
| Improve this Doc View SourceMethod
The constructor this object wraps.
Declaration
public MethodInfo Method { get; }
Property Value
| Type | Description |
|---|---|
| System.Reflection.MethodInfo |


Pet owners shared the funniest pictures of their cats compiled by Buzzfeed
Photos show their cats squeezing into the tightest resting places to get cosy
Some cats settled down in jars and others in bowls and even a violin case
Cats are known to have a mind of their own, and these pictures prove just how determined our feline friends are to get their own way.
In a gallery compiled by Buzzfeed and found across Twitter, pet owners went online to share their cat's funniest resting places, baffled by how they managed to squeeze into the tightest spots.
In one case two kittens decided a double bowl would be the most convenient place for them to settle down, while elsewhere a grumpy cat folded himself into a vase, and another chose a violin case as the perfect sleeping area.
We take a look at the most inconvenient - but apparently comfortable - places our furry pals have settled down in.


Coronavirus disease (COVID-19) is an infectious disease caused by a newly discovered coronavirus. Most people infected with the COVID-19 virus will experience mild to moderate respiratory illness and recover without requiring special treatment. Older people, and those with underlying medical problems like cardiovascular disease, diabetes, chronic respiratory disease, and cancer are more likely to develop serious illness.
Click down below to see the total amount of people effected by Covid-19
The best way to prevent and slow down transmission is be well informed about the COVID-19 virus, the disease it causes and how it spreads. Protect yourself and others from infection by washing your hands or using an alcohol based rub frequently and not touching your face.The COVID-19 virus spreads primarily through droplets of saliva or discharge from the nose when an infected person coughs or sneezes, so it’s important that you also practice respiratory etiquette (for example, by coughing into a flexed elbow). Down below is a map breaking down the cases of caron virus outside China
Click the button "View" down below to see total deaths and confirmed cases of caron virus from around the world.