1 About the course
Recent technological advances have made it possible to obtain genome-wide transcriptome data from single cells using high-throughput sequencing (scRNA-seq). Even though scRNA-seq makes it possible to address problems that are intractable with bulk RNA-seq data, analysing scRNA-seq is also more challenging.
In this course we will be surveying the existing problems as well as the available computational and statistical frameworks available for the analysis of scRNA-seq.
1.1 Registration
1.4 Prerequisites
The course is intended for those who have basic familiarity with Unix and the R scripting language.
We will also assume that you are familiar with mapping and analysing bulk RNA-seq data as well as with the commonly available computational tools.
We recommend attending the Introduction to RNA-seq and ChIP-seq data analysis or the Analysis of high-throughput sequencing data with Bioconductor before attending this course.
2 Technical requirements
We tried to make this course purely R-based. However, one of the methods that we describe (SNN-Cliq) is only partly R-based. It makes a simple python call from R and requires a user to have rights to write to the current directory. You also need to download this file and put it in ~/snn-cliq/
directory.
Other than that, before running the course exercises, all you need to do is to install the following packages in your R:
devtools for installing packages from GitHub:
install.packages("devtools")
scRNA.seq.funcs - R package containing our own functions used in this course:
devtools::install_github("hemberg-lab/scRNA.seq.funcs")
mvoutlier - for an automatic outlier detection in the scater package.
install.packages("mvoutlier")
M3D for identification of important and DE genes, developed by Tallulah Andrews:
devtools::install_github("tallulandrews/M3D", ref = "release")
RUVSeq for normalization using ERCC controls:
## try http:// if https:// URLs are not supported
source("https://bioconductor.org/biocLite.R")
biocLite("RUVSeq")
ROCR for performance estimations:
install.packages("ROCR")
limma for plotting Venn diagrams:
## try http:// if https:// URLs are not supported
source("https://bioconductor.org/biocLite.R")
biocLite("limma")
DESeq2 for calculation of DE genes:
## try http:// if https:// URLs are not supported
source("https://bioconductor.org/biocLite.R")
biocLite("DESeq2")
scde for calculation of DE genes:
devtools::install_github("hms-dbmi/scde", build_vignettes = FALSE)
Installation on Mac OS X may require this additional gfortran library:
curl -O http://r.research.att.com/libs/gfortran-4.8.2-darwin13.tar.bz2 sudo tar fvxz gfortran-4.8.2-darwin13.tar.bz2 -C /
See the help page for additional support.
pheatmap for plotting good looking heatmaps:
install.packages("pheatmap")
pcaMethods required by pcaReduce package below for unsupervised clustering of scRNA-seq data:
## try http:// if https:// URLs are not supported
source("https://bioconductor.org/biocLite.R")
biocLite("pcaMethods")
pcaReduce for unsupervised clustering of scRNA-seq data (bioRxiv):
devtools::install_github("JustinaZ/pcaReduce")
Rtsne for unsupervised clustering of scRNA-seq data:
install.packages("Rtsne")
SC3 for unsupervised clustering of scRNA-seq data (bioRxiv):
devtools::install_github("hemberg-lab/SC3", ref = "R-old")
- Before running SC3 for the first time only, please start R and enter:
RSelenium::checkForServer()
3 Introduction to single-cell RNA-seq
3.1 Bulk RNA-seq
- A major breakthrough (replaced microarrays) in the late 00’s and has been widely used since
- Provides an average expression level for each gene from a large population of input cells
- Useful for comparative transcriptomics, e.g. samples of the same tissue from different species
- Useful for quantifying expression signatures from ensembles, e.g. in disease studies
- Insufficient for studying heterogeneous systems, e.g. early development studies, complex tissues (brain)
- Does not provide insights into the stochastic nature of gene expression
3.2 scRNA-seq
- A new technology, first publication by Tang et al in 2009
- Instead of providing an average of expression of a population of cells, scRNA-seq provides a distribution of expression levels from a population of cells
- Allows to study new biological questions in which cell-specific changes in transcriptome are important, e.g. cell type identification, inference of gene regulatory networks across the cells, stochastic component of transcription
- Datasets range from \(10^2\) to \(10^4\) cells and increase in size every year
- Currently there are several different protocols in use, e.g. SMART-seq2, CELL-seq and Drop-seq
- Several computational analysis methods from bulk RNA-seq can be used
- In most cases requires adaptation of the existing methods or development of new ones
3.3 Protocol
image from Wikipedia - Single cell sequencing
Overall, experimental scRNA-seq protocols are similar to the methods used for bulk RNA-seq. For a discussion on experimental methods, please see reviews by Saliba et al, Handley et al or Kolodziejczyk et al.
3.4 Analysis
This course is concerned with the computational analysis of the data obtained from scRNA-seq experiments. Even though the format of the data is the same as for bulk RNA-seq, the fact that individual cells are sampled means that the data should be analyzed differently. We will provide an overview of how to process a scRNA-seq sample and how to analyze the data to provide biological insights.
Flowchart for analyzing scRNA-seq data.
3.5 Challenges
The main difference between bulk and single cell RNA-seq is that each sequencing library represents a single cell, instead of a population of cells. Therefore, significant attention has to be paid to comparison of the results from different cells (sequencing libraries). The main sources of discrepancy between the libraries are:
- Amplification (up to 1 million fold)
- Gene ‘dropouts’ in which a gene is observed at a moderate expression level in one cell but is not detected in another cell (Kharchenko et al).
In both cases the discrepancies are introduced due to low starting transcript amount (from one cell only) and have yet to be addressed by improving the experimental protocol.
3.6 Controls
To address challenges in technical variation between scRNA sequencing libraries two quantitative standards were introduced. They allow to normalize gene expression levels across different cells.
3.6.1 ERCC spike-ins
One standard, strongly recommended for all scRNA-seq experiments is to use extrinsic spike-in molecules. These molecules are added to the lysate before the reverse transcription. The most popular and widely used artificial spike-ins are from External RNA Control Consortium (ERCC). It contains 92 synthetic spikes based on bacterial sequences. Normalization using spike-ins is based on the fact that the number of molecules of each spike-in RNA species should be the same across all single-cell libraries.
3.6.2 UMIs
Another method of standartisation is to use Unique Molecular Identifiers (UMIs). Instead of sequencing the amplified reads from a cell library, it allows for sequencing reads derived solely from 3’ or 5’ end of the amplified transcript. UMIs are added as barcodes to the individual RNA molecules. This approach provides an estimate of the number of transcripts that is independent of amplification biases.
4 Construction of expression matrix
4.1 Reads QC
The output from a scRNA-seq experiment is a large collection of short cDNA reads. The first step is to ensure that the reads are of high quality. In application to scRNA-seq, this can be performed by using standard bulk RNA-seq QC tools, such as FastQC or Kraken. Currently, there are no specialized tools for scRNA-seq available, so we use FastQC.
Assuming that our reads are in experiment.bam, we run FastQC as
$<path_to_fastQC>/fastQC experiment.bam
Below is an example of the output from FastQC for a dataset of 125 bp reads. Here, the quality of the reads is overall high, so we can proceed the analysis with confidence.
Additionally, the data can be visualized using the Integrative Genomics Browser (IGV).
4.2 Reads alignment
Once the low-quality reads have been removed, the remaining reads can be mapped to a reference genome. Again, there are no special purpose methods for this, so we can use the STAR or the TopHat aligner.
An example of how to map reads.bam to using STAR hg38 is
$<path_to_STAR>/STAR --runThreadN 1 --runMode alignReads
--readFilesIn reads1.fq.gz reads2.fq.gz --readFilesCommand zcat --genomeDir <path>
--parametersFiles FileOfMoreParameters.txt --outFileNamePrefix <outpath>/output
Note, if the spike-ins are used, the reference sequence should be augmented with the DNA sequence of the spike-in molecules before mapping.
Note, when UMIs are used, their barcodes should be removed from every read.
Once we have mapped the reads for each cell to the reference genome, we need to make sure that a sufficient number of reads from each cell could be mapped to the reference genome. In our experience, the fraction of mappable reads is 60-70%. However, this result may vary depending on protocol, read length and settings for the read alignment. As a general rule, we expect all cells to have a similar fraction of mapped reads, so any outliers should be inspected and possibly removed.
4.3 Alignment example
The histogram below shows the total number of reads mapped to each cell for an scRNA-seq experiment. Each bar represents one cell, and they have been sorted in ascending order by the total number of reads per cell. The three red arrows indicate cells that are outliers in terms of their coverage and they should be removed from further analysis. The two yellow arrows point to cells with a surprisingly large number of unmapped reads. However, we deem the discrepancy as small and we retain the cells for now.
4.4 Mapping QC
After mapping the raw sequencing to the genome we should evaluate the quality of the mapping. There are many ways to measure this including: amount of reads mapping to rRNA/tRNAs, proportion of uniquely mapping reads, reads mapping across splice junctions, read depth along the transcripts. Methods developed for bulk RNA-seq, such as RSeQC, are applicable to single-cell data:
python <RSeQCpath>/geneBody_coverage.py -i input.bam -r genome.bed -o output.txt
python <RSeQCpath>/bam_stat.py -i input.bam -r genome.bed -o output.txt
python <RSeQCpath>/split_bam.py -i input.bam -r rRNAmask.bed -o output.txt
However the expected results will depend on the experimental protocol, e.g. many scRNA-seq methods use poly-A selection to avoid sequencing rRNAs which results in a 3’ bias in the read coverage across the genes (aka gene body coverage). The figure below shows this 3’ bias as well as three cells which were outliers and removed from the dataset:
4.5 Reads quantification
The next step is to quantify the expression level of each gene for each cell. For mRNA data, we can use one of the tools which has been developed for bulk RNA-seq data, e.g. HT-seq or FeatureCounts
# include multimapping
<featureCounts_path>/featureCounts -O -M -Q 30 -p -a genome.gtf -o outputfile input.bam
# exclude multimapping
<featureCounts_path>/featureCounts -Q 30 -p -a genome.gtf -o outputfile input.bam
Note, when UMIs are used, the expression counts can be collapsed by summing the number of unique barcodes associated with all reads mapped to a given gene.
5 scater package
5.1 Introduction
scater is a single-cell analysis toolkit for expression with R. This package contains useful tools for the analysis of single-cell gene expression data using the statistical software R. The package places an emphasis on tools for quality control, visualisation and pre-processing of data before further downstream analysis.
scater enables the following:
- Automated computation of QC metrics
- Transcript quantification from read data with pseudo-alignment
- Data format standardisation
- Rich visualisations for exploratory analysis
- Seamless integration into the Bioconductor universe
- Simple normalisation methods
We highly recommend to use scater for any single-cell RNA-seq analysis you will be doing in the future. scater is the basis of the first part of the course and therefore we will spend some time explaining its details.
5.2 scater workflow
5.3 Terminology
(this chapter is taken from the scater vignette)
- The capabilities of scater are built on top of Bioconductor’s Biobase.
- In Bioconductor terminology we assay numerous “features” for a number of “samples”.
- Features, in the context of scater, correspond most commonly to genes or transcripts, but could be any general genomic or transcriptomic regions (e.g. exon) of interest for which we take measurements.
- In the following chapters it may be more intuitive to mentally replace “feature” with “gene” or “transcript” (depending on the context of the study) wherever “feature” appears.
- In the scater context, “samples” refer to individual cells that we have assayed.
5.4 SCESet class
(this chapter is taken from the scater vignette)
In scater we organise single-cell expression data in objects of the SCESet class. The class inherits the Bioconductor ExpressionSet class, which provides a common interface familiar to those who have analyzed microarray experiments with Bioconductor. The class requires three input files:
- exprs, a numeric matrix of expression values, where rows are features, and columns are cells
- phenoData, an AnnotatedDataFrame object, where rows are cells, and columns are cell attributes (such as cell type, culture condition, day captured, etc.)
- featureData, an AnnotatedDataFrame object, where rows are features (e.g. genes), and columns are feature attributes, such as biotype, gc content, etc.
For more details about other features inherited from Bioconductor’s ExpressionSet class, type ?ExpressionSet
at the R prompt.
When your data is wrapped in the SCESet class, scater will do the dirty job of calculating different properties of the data automatically. You will see how it works in the next chapters.
6 Expression QC (UMI)
6.1 Introduction
Once gene expression has been quantified the resulting expression matrix must be examined for poor quality cells which were not detected from QC of the raw reads. Failure to remove low quality cells at this stage will add a large amount of technical noise which will obscure the biological signals of interest in downstream analysis. We will demonstrate some simple filters that can be applied directly to the gene expression matrix with minimal extrinsic information.
Typically, the results are summarized using an expression matrix. In the expression matrix, each row represents a gene and each column represents a cell.
To illustrate cell QC, we consider a dataset from lymphoblast and induced pluripotent stem cells generated by John Blischak in Yoav Gilad’s lab at the University of Chicago. The experiments were carried out on the Fluidigm C1 platform and to facilitate the quantification both unique molecular identifiers (UMIs) and ERCC spike-ins were used. For our purposes you need to download the files annotation.txt
, molecules.txt
, and reads.txt
from here into the blischak
folder in your working directory. These files are the copies of the original files made on the 15/03/16. We will use these copies for reproducibility purposes.
To illustrate how one can standardise the analysis of scRNA-seq data we will also be using the scater package, described in the previous chapter.
6.2 Blischak dataset
library(scater, quietly = TRUE)
library(knitr)
options(stringsAsFactors = FALSE)
opts_chunk$set(out.width='90%', fig.align = 'center')
Load the data and annotations:
molecules <- read.table("blischak/molecules.txt", sep = "\t")
anno <- read.table("blischak/annotation.txt", sep = "\t", header = TRUE)
How does the data look like?
knitr::kable(
head(molecules[ , 1:3]), booktabs = TRUE,
caption = 'A table of the first 6 rows and 3 columns of the molecules table.'
)
| NA19098.r1.A01 | NA19098.r1.A02 | NA19098.r1.A03 | |
|---|---|---|---|
| ENSG00000237683 | 0 | 0 | 0 |
| ENSG00000187634 | 0 | 0 | 0 |
| ENSG00000188976 | 3 | 6 | 1 |
| ENSG00000187961 | 0 | 0 | 0 |
| ENSG00000187583 | 0 | 0 | 0 |
| ENSG00000187642 | 0 | 0 | 0 |
knitr::kable(
head(anno), booktabs = TRUE,
caption = 'A table of the first 6 rows of the anno table.'
)
| individual | replicate | well | batch | sample_id |
|---|---|---|---|---|
| NA19098 | r1 | A01 | NA19098.r1 | NA19098.r1.A01 |
| NA19098 | r1 | A02 | NA19098.r1 | NA19098.r1.A02 |
| NA19098 | r1 | A03 | NA19098.r1 | NA19098.r1.A03 |
| NA19098 | r1 | A04 | NA19098.r1 | NA19098.r1.A04 |
| NA19098 | r1 | A05 | NA19098.r1 | NA19098.r1.A05 |
| NA19098 | r1 | A06 | NA19098.r1 | NA19098.r1.A06 |
The data consists of 3 individuals and 3 replicates and therefore has 9 batches in total.
Let’s standardise the analysis by using the scater package described above. First, make scater SCESet classes:
pheno_data <- new("AnnotatedDataFrame", anno)
rownames(pheno_data) <- pheno_data$sample_id
umi <- scater::newSCESet(
countData = molecules,
phenoData = pheno_data
)
Remove genes that are not expressed in any cell:
keep_feature <- rowSums(is_exprs(umi)) > 0
umi <- umi[keep_feature, ]
Define control features (genes) - ERCC spike-ins and mitochondrial genes (provided by the authors):
ercc <- featureNames(umi)[grepl("ERCC-", featureNames(umi))]
mt <- c("ENSG00000198899", "ENSG00000198727", "ENSG00000198888",
"ENSG00000198886", "ENSG00000212907", "ENSG00000198786",
"ENSG00000198695", "ENSG00000198712", "ENSG00000198804",
"ENSG00000198763", "ENSG00000228253", "ENSG00000198938",
"ENSG00000198840")
Calculate the quality metrics:
umi <- scater::calculateQCMetrics(
umi,
feature_controls = list(ERCC = ercc, MT = mt)
)
6.3 Gene QC
6.3.1 Gene dropouts
First, one can look at the gene expression frequency versus mean expression level to assess the effects of technical dropout in the dataset.
scater::plotQC(umi, type = "exprs-freq-vs-mean")
Interestingly, only less than half of the genes are expressed in more than 50% of the cells.
6.3.2 Gene expression
One can also look at the number of reads consumed by the top 50 expressed genes.
scater::plotQC(umi, type = "highest-expression")
Not surprisingly, most of the very top expressed genes are either ERCCs or MT genes (Feature controls).
6.4 Gene filtering
We can remove genes whose expression level is considered “undetectable”. We define a detectable gene expression level, in which at least 2 cells contain more than 1 read mapping to the gene.
filter_genes <- apply(counts(umi), 1, function(x) length(x[x > 1]) >= 2)
fData(umi)$use <- filter_genes
knitr::kable(
as.data.frame(table(filter_genes)),
booktabs = TRUE,
row.names = FALSE,
caption = 'The number of genes removed by gene filter (FALSE)'
)
| filter_genes | Freq |
|---|---|
| FALSE | 4512 |
| TRUE | 14214 |
Depending on the cell-type, protocol and sequencing depth, other cut-offs may be appropriate.
6.5 Cell QC
6.5.1 Library size
Next we will look at the total number of RNA molecules detected per sample (if we were using read counts rather than UMI counts this would be total reads). Wells with few reads/molecules are likely to have been broken or failed to capture a cell, thus should be removed.
hist(
umi$total_counts,
breaks = 100
)
Exercise
Apply a suitable filter to remove the cells that contain too few molecules. What distribution do you expect that the total number of molecules for each cell should follow?
Answer
filter_by_total_counts <- (umi$total_counts > 10000)
knitr::kable(
as.data.frame(table(filter_by_total_counts)),
booktabs = TRUE,
row.names = FALSE,
caption = 'The number of cells removed by total counts filter (FALSE)'
)
| filter_by_total_counts | Freq |
|---|---|
| FALSE | 2 |
| TRUE | 862 |
6.5.2 Detected genes (1)
One of the simplest measures of cell quality is the number of genes that were detected. Cells with few detected genes may have been broken or dead prior to capture.
hist(
umi$total_features,
breaks = 100
)
Here we see that most cells have between 5,000-11,000 detected genes, which is normal for high-depth scRNA-seq. However this varies by experimental protocol and sequencing depth with droplet-based methods or lower sequencing-depth detecting fewer genes per cell. The feature to note is the “heavy tail” of the left hand side of the distribution. If detection rates were equal across the cells then the distribution should be approximately normal. Thus we remove those cells in the tail of the distribution (<5,000 detected genes).
filter_by_expr_features <- (umi$total_features > 5000)
knitr::kable(
as.data.frame(table(filter_by_expr_features)),
booktabs = TRUE,
row.names = FALSE,
caption = 'The number of cells removed by total features filter (FALSE)'
)
| filter_by_expr_features | Freq |
|---|---|
| FALSE | 16 |
| TRUE | 848 |
6.5.3 Detected genes (2)
Additionally, we can plot the library size as a function of the number of the detected genes. This will also allow us to find other cell outliers.
scater::plotPhenoData(
umi,
aes(x = total_features, y = log10(total_counts), colour = batch)
)
6.5.4 ERCCs and MTs
Another measures of cell quality is the ration between ERCC spike-in RNAs and endogenous RNAs. This can be used to estimate the total amount of RNA in the captured cells. Cells with a high level of spike-in RNAs had low starting amounts of RNA, likely due to the cell being dead or stressed, or the RNA being degraded.
scater::plotPhenoData(
umi,
aes_string(x = "total_features",
y = "pct_counts_feature_controls_MT",
colour = "batch")
)
scater::plotPhenoData(
umi,
aes_string(x = "total_features",
y = "pct_counts_feature_controls_ERCC",
colour = "batch")
)
This analysis shows that majority of the cells from NA19098.r2 batch have a very high ERCC/Endo ratio. Indeed, it has been shown by the authors that this batch contains cells of smaller size.
Exercise
Create filters for removing batch NA19098.r2 and cells with high expression of mitochondrial genes (>10% of total counts in a cell).
Answer
filter_by_ERCC <- umi$batch != "NA19098.r2"
knitr::kable(
as.data.frame(table(filter_by_ERCC)),
booktabs = TRUE,
row.names = FALSE,
caption = 'The number of cells removed by ERCC filter (FALSE)'
)
| filter_by_ERCC | Freq |
|---|---|
| FALSE | 96 |
| TRUE | 768 |
filter_by_MT <- umi$pct_counts_feature_controls_MT < 10
knitr::kable(
as.data.frame(table(filter_by_MT)),
booktabs = TRUE,
row.names = FALSE,
caption = 'The number of cells removed by MT filter (FALSE)'
)
| filter_by_MT | Freq |
|---|---|
| FALSE | 31 |
| TRUE | 833 |
6.6 Cell filtering
6.6.1 Default
To filter out outlier cells one could use the defaults provided by the scater package:
filter_on_total_features: filter out cells based on their total_features being (by default) more than 5 median absolute deviations from the median total_features for the dataset
filter_on_total_counts: filter out cells based on their log10-total_counts being (by default) more than 5 median absolute deviations from the median log10-total_counts for the dataset?
filter_on_pct_counts_feature_controls: filter out cells on the basis that the percentage of counts from feature controls is higher than a defined threhold (default is 80%)?
is_cell_control: filter out cells that were defined as controls
umi$use_default <- (
# remove cells with unusual numbers of genes
!umi$filter_on_total_features &
# sufficient molecules counted
!umi$filter_on_total_counts &
# sufficient endogenous RNA
!umi$filter_on_pct_counts_feature_controls_ERCC &
# remove cells with unusual number of reads in MT genes
!umi$filter_on_pct_counts_feature_controls_MT &
# controls shouldn't be used in downstream analysis
!umi$is_cell_control
)
knitr::kable(
as.data.frame(table(umi$use_default)),
booktabs = TRUE,
row.names = FALSE,
caption = 'The number of cells removed by default filter (FALSE)'
)
| Var1 | Freq |
|---|---|
| FALSE | 6 |
| TRUE | 858 |
This filtering can be performed even without looking at the plots above.
6.6.2 Automatic
Another option available in scater is to conduct PCA on a set of QC metrics. The advantage of doing this is that the QC metrics focus on technical aspects of the libraries that are likely to distinguish problematics cells. Automatic outlier detection on PCA plots using QC metrics is available to help identify potentially problematic cells.
By default, the following metrics are used for PCA-based outlier detection:
- pct_counts_top_100_features
- total_features
- pct_counts_feature_controls
- n_detected_feature_controls
- log10_counts_endogenous_features
- log10_counts_feature_controls
A particular set of variables to be used can be specified with the selected_variables argument as shown in the example below.
umi <-
scater::plotPCA(umi,
size_by = "total_features",
shape_by = "filter_on_total_features",
pca_data_input = "pdata",
detect_outliers = TRUE,
return_SCESet = TRUE)
## The following cells/samples are detected as outliers:
## NA19098.r2.A01
## NA19098.r2.A02
## NA19098.r2.A06
## NA19098.r2.A09
## NA19098.r2.A10
## NA19098.r2.A12
## NA19098.r2.B01
## NA19098.r2.B03
## NA19098.r2.B04
## NA19098.r2.B05
## NA19098.r2.B07
## NA19098.r2.B11
## NA19098.r2.B12
## NA19098.r2.C01
## NA19098.r2.C02
## NA19098.r2.C03
## NA19098.r2.C04
## NA19098.r2.C05
## NA19098.r2.C06
## NA19098.r2.C07
## NA19098.r2.C08
## NA19098.r2.C09
## NA19098.r2.C10
## NA19098.r2.C11
## NA19098.r2.C12
## NA19098.r2.D01
## NA19098.r2.D02
## NA19098.r2.D03
## NA19098.r2.D04
## NA19098.r2.D07
## NA19098.r2.D08
## NA19098.r2.D09
## NA19098.r2.D10
## NA19098.r2.D12
## NA19098.r2.E01
## NA19098.r2.E02
## NA19098.r2.E03
## NA19098.r2.E04
## NA19098.r2.E05
## NA19098.r2.E06
## NA19098.r2.E07
## NA19098.r2.E12
## NA19098.r2.F01
## NA19098.r2.F02
## NA19098.r2.F07
## NA19098.r2.F08
## NA19098.r2.F09
## NA19098.r2.F10
## NA19098.r2.F11
## NA19098.r2.F12
## NA19098.r2.G01
## NA19098.r2.G02
## NA19098.r2.G03
## NA19098.r2.G05
## NA19098.r2.G06
## NA19098.r2.G08
## NA19098.r2.G09
## NA19098.r2.G10
## NA19098.r2.G11
## NA19098.r2.H01
## NA19098.r2.H02
## NA19098.r2.H03
## NA19098.r2.H04
## NA19098.r2.H05
## NA19098.r2.H06
## NA19098.r2.H07
## NA19098.r2.H08
## NA19098.r2.H10
## NA19098.r2.H12
## NA19101.r3.A02
## NA19101.r3.C12
## NA19101.r3.D01
## NA19101.r3.E08
## Variables with highest loadings for PC1 and PC2:
##
## PC1 PC2
## --------------------------------- ----------- ----------
## pct_counts_top_100_features 0.4771343 0.3009332
## pct_counts_feature_controls 0.4735839 0.3309562
## n_detected_feature_controls 0.1332811 0.5367629
## log10_counts_feature_controls -0.1427373 0.5911762
## total_features -0.5016681 0.2936705
## log10_counts_endogenous_features -0.5081855 0.2757918
knitr::kable(
as.data.frame(table(umi$outlier)),
booktabs = TRUE,
row.names = FALSE,
caption = 'The number of cells removed by automatic filter (FALSE)'
)
| Var1 | Freq |
|---|---|
| FALSE | 791 |
| TRUE | 73 |
6.6.3 Manual
However, since we performed a more detailed analysis, visualized different features and defined our own filters we can use them instead of the default ones:
umi$use <- (
# sufficient features (genes)
filter_by_expr_features &
# sufficient molecules counted
filter_by_total_counts &
# sufficient endogenous RNA
filter_by_ERCC &
# remove cells with unusual number of reads in MT genes
filter_by_MT
)
knitr::kable(
as.data.frame(table(umi$use)),
booktabs = TRUE,
row.names = FALSE,
caption = 'The number of cells removed by manual filter (FALSE)'
)
| Var1 | Freq |
|---|---|
| FALSE | 141 |
| TRUE | 723 |
6.7 Compare filterings
Exercise
Compare the default, automatic and manual cell filters. Plot a Venn diagram of the outlier cells from these filterings.
Hint: Use limma::vennCounts
and limma::vennDiagram
functions from the limma package to make a Venn diagram.
Answer
def <- colnames(umi)[!umi$use_default]
auto <- colnames(umi)[umi$outlier]
man <- colnames(umi)[!umi$use]
venn.diag <- limma::vennCounts(cbind(colnames(umi) %in% def,
colnames(umi) %in% auto,
colnames(umi) %in% man))
limma::vennDiagram(venn.diag,
names = c("Default", "Automatic", "Manual"),
circle.col = c("magenta", "blue", "green"))
6.8 Save the data
Dimensions of the QCed dataset (do not forget about the gene filter we defined above):
dim(umi[fData(umi)$use, pData(umi)$use])
## Features Samples
## 14214 723
Save the data:
saveRDS(umi, file = "blischak/umi.rds")
6.9 Exercise
Perform exactly the same QC analysis with read counts of the same Blischak data. Use blischak/reads.txt
file to load the reads. Once you have finished please compare your results to ours (next chapter).
7 Expression QC (Reads)
| NA19098.r1.A01 | NA19098.r1.A02 | NA19098.r1.A03 | |
|---|---|---|---|
| ENSG00000237683 | 0 | 0 | 0 |
| ENSG00000187634 | 0 | 0 | 0 |
| ENSG00000188976 | 57 | 140 | 1 |
| ENSG00000187961 | 0 | 0 | 0 |
| ENSG00000187583 | 0 | 0 | 0 |
| ENSG00000187642 | 0 | 0 | 0 |
| individual | replicate | well | batch | sample_id |
|---|---|---|---|---|
| NA19098 | r1 | A01 | NA19098.r1 | NA19098.r1.A01 |
| NA19098 | r1 | A02 | NA19098.r1 | NA19098.r1.A02 |
| NA19098 | r1 | A03 | NA19098.r1 | NA19098.r1.A03 |
| NA19098 | r1 | A04 | NA19098.r1 | NA19098.r1.A04 |
| NA19098 | r1 | A05 | NA19098.r1 | NA19098.r1.A05 |
| NA19098 | r1 | A06 | NA19098.r1 | NA19098.r1.A06 |
| filter_genes | Freq |
|---|---|
| FALSE | 2445 |
| TRUE | 16281 |
| filter_by_total_counts | Freq |
|---|---|
| FALSE | 180 |
| TRUE | 684 |
| filter_by_expr_features | Freq |
|---|---|
| FALSE | 16 |
| TRUE | 848 |
| filter_by_ERCC | Freq |
|---|---|
| FALSE | 103 |
| TRUE | 761 |
| filter_by_MT | Freq |
|---|---|
| FALSE | 18 |
| TRUE | 846 |
| Var1 | Freq |
|---|---|
| FALSE | 37 |
| TRUE | 827 |
## The following cells/samples are detected as outliers:
## NA19098.r1.B10
## NA19098.r1.D07
## NA19098.r1.E04
## NA19098.r1.F06
## NA19098.r1.H08
## NA19098.r1.H09
## NA19098.r2.A01
## NA19098.r2.A06
## NA19098.r2.A09
## NA19098.r2.A12
## NA19098.r2.B01
## NA19098.r2.B11
## NA19098.r2.B12
## NA19098.r2.C04
## NA19098.r2.C09
## NA19098.r2.D02
## NA19098.r2.D03
## NA19098.r2.D09
## NA19098.r2.E04
## NA19098.r2.E07
## NA19098.r2.F01
## NA19098.r2.F11
## NA19098.r2.G01
## NA19098.r2.G05
## NA19098.r2.G10
## NA19098.r2.H01
## NA19098.r2.H07
## NA19098.r2.H08
## NA19098.r2.H12
## NA19098.r3.A05
## NA19098.r3.A07
## NA19098.r3.B02
## NA19098.r3.C07
## NA19098.r3.E05
## NA19098.r3.E08
## NA19098.r3.E09
## NA19098.r3.F11
## NA19098.r3.F12
## NA19098.r3.G02
## NA19098.r3.G03
## NA19098.r3.G04
## NA19098.r3.G11
## NA19098.r3.G12
## NA19098.r3.H08
## NA19101.r1.A01
## NA19101.r1.A12
## NA19101.r1.B01
## NA19101.r1.B06
## NA19101.r1.E09
## NA19101.r1.E11
## NA19101.r1.F05
## NA19101.r1.F10
## NA19101.r1.G01
## NA19101.r1.G06
## NA19101.r1.H04
## NA19101.r1.H09
## NA19101.r2.A03
## NA19101.r2.C10
## NA19101.r2.E05
## NA19101.r2.F02
## NA19101.r2.H04
## NA19101.r2.H10
## NA19101.r3.A02
## NA19101.r3.A03
## NA19101.r3.A05
## NA19101.r3.A09
## NA19101.r3.B05
## NA19101.r3.C01
## NA19101.r3.C09
## NA19101.r3.C12
## NA19101.r3.D01
## NA19101.r3.D04
## NA19101.r3.D07
## NA19101.r3.D09
## NA19101.r3.E08
## NA19101.r3.F09
## NA19101.r3.G09
## NA19101.r3.H01
## NA19101.r3.H03
## NA19101.r3.H07
## NA19101.r3.H09
## NA19239.r1.F05
## NA19239.r1.G05
## NA19239.r2.B01
## NA19239.r2.B03
## NA19239.r2.B10
## NA19239.r2.B11
## NA19239.r2.C03
## NA19239.r2.C06
## NA19239.r2.C08
## NA19239.r2.D07
## NA19239.r2.D09
## NA19239.r2.E09
## NA19239.r2.F04
## NA19239.r2.F06
## NA19239.r2.F07
## NA19239.r2.F12
## NA19239.r2.G03
## NA19239.r2.G08
## NA19239.r2.H02
## NA19239.r2.H03
## NA19239.r2.H07
## NA19239.r3.A01
## NA19239.r3.B09
## NA19239.r3.C04
## NA19239.r3.C07
## NA19239.r3.E01
## NA19239.r3.E03
## NA19239.r3.E12
## NA19239.r3.H02
## NA19239.r3.H10
## Variables with highest loadings for PC1 and PC2:
##
## PC1 PC2
## --------------------------------- ----------- ----------
## pct_counts_feature_controls 0.5057646 0.2473134
## pct_counts_top_100_features 0.4888852 0.2277068
## n_detected_feature_controls 0.0231277 0.6235516
## log10_counts_feature_controls -0.1226860 0.6576822
## total_features -0.4655518 0.2219694
## log10_counts_endogenous_features -0.5223679 0.1278782
| Var1 | Freq |
|---|---|
| FALSE | 753 |
| TRUE | 111 |
| Var1 | Freq |
|---|---|
| FALSE | 254 |
| TRUE | 610 |
## Features Samples
## 16281 610
8 Expression overview
8.1 Introduction
Here we will continue to work with the filtered blischak dataset produced in the previous chapter. We will look at what happened to the expression matrix after the quality control step.
8.2 Top 500 genes
With scater one can look at the proportion of reads accounted by the top 500 expressed genes.
8.2.1 Before QC
8.2.2 After QC
8.3 PCA plot
The easiest thing to overview the data is to transform it using the principal component analysis and then visualize the first two principal components. Again the scater package provides several very useful functions to make this analysis straightforward.
8.3.1 Before QC
8.3.2 After QC
8.4 Diffusion map
Another way of representing the data is a diffusion map. It is very useful if the cells represent a continuous process (e.g. development).
8.4.1 Before QC
8.4.2 After QC
8.5 tSNE map
Another way of representing the data is a tSNE map.
8.5.1 Before QC
8.5.2 After QC
8.6 Exercise
Perform the same analysis with read counts of the Blischak data. Use blischak/reads.rds
file to load the reads SCESet object. Once you have finished please compare your results to ours (next chapter).
9 Expression overview (Reads)
10 Confounding factors
10.1 Introduction
There are a very large number of potential confounders, artifacts and biases in sc-RNA-seq data One of the main challenges in analyzing scRNA-seq data stems from the fact that it is difficult to carry out a true technical replicate (why?) to distinguish biological and technical variability. Exploring the effects of such variabilities (both those recorded during the experiment and computed QC metrics) is crucial for appropriate modeling of the data.
The scater package provides a set of methods specifically for quality control of experimental and explanatory variables.
Here we will continue to work with the Blischak data that was used in the previous chapter.
The umi.qc
dataset contains filtered cells and genes. Our next step is to explore technical drivers of variability in the data to inform data normalisation before downstream analysis.
10.2 Correlations with PCs
Let’s first look again at the PCA plot of the QCed dataset:scater allows one to identify principle components that correlate with experimental and QC variables of interest (it ranks principle components by \(R^2\) from a linear model regressing PC value against the variable of interest).
Let’s test whether some of the variables correlate with any of the PCs.
10.2.1 Detected genes
Indeed, we can see that PC1 can be completely explained by the number of the detected genes. In fact, it was also visible on the PCA plot above. This is a well-known issue in scRNA-seq and was described here.
10.2.2 Control ERCCs
10.2.3 Control MTs
10.3 Explanatory variables
scater can also compute the marginal \(R^2\) for each variable when fitting a linear model regressing expression values for each gene against just that variable, and display a density plot of the gene-wise marginal \(R^2\) values for the variables.
This analysis indicates that the number of detected genes (again) and also the sequencing depth (number of counts) have substantial explanatory power for many genes, so these variables are good candidates for conditioning out in a normalisation step, or including in downstream statistical models. Expression of ERCCs also appears to be an important explanatory variable.
10.4 Other confounders
In addition to correcting for batch, there are other factors that one may want to compensate for. As with batch correction, these adjustments require extrinsic information. One popular method is scLVM which allows you to identify and subtract the effect from processes such as cell-cycle or apoptosis.
10.5 Exercise
Perform the same analysis with read counts of the Blischak data. Use blischak/reads.rds
file to load the reads SCESet object. Once you have finished please compare your results to ours (next chapter).
11 Confounding factors (Reads)
12 Normalization for library size
12.1 Introduction
In the previous chapter we identified important confounding factors and explanatory variables. scater allows one to account for these variables in subsequent statistical models or to condition them out using normaliseExprs()
, if so desired. This can be done by providing a design matrix to normaliseExprs()
. We are not covering this topic here, but you can try to do it yourself as an exercise.
Instead we will explore how simple size-factor normalisations correcting for library size can remove the effects of some of the confounders and explanatory variables.
12.2 Library size
Library sizes vary because of the various reasons: * scRNA-seq data is often sequenced on highly multiplexed platforms the total reads which are derived from each cell may differ substantially. * Protocols may differ in terms of their coverage of each transcript, their bias based on the average content of A/T nucleotides, or their ability to capture short transcripts.
Ideally, we would like to compensate for all of these differences and biases when comparing data from two different experiments.
Many methods to correct for library size have been developped for bulk RNA-seq and can be equally applied to scRNA-seq (eg. UQ, SF, CPM, RPKM, FPKM, TPM). Some quantification methods (eg. Cufflinks, RSEM) incorporated library size when determining gene expression estimates thus do not require this normalization.
We will continue to work with the Blischak data that was used in the previous chapter and show how scater makes it easy to perform different types of size-factor normalizations.
12.3 Normalisations
The simplest way to normalize this data is to convert it to counts per million (CPM) by dividing each column by its total then multiplying by 1,000,000. Note that spike-ins should be excluded from the calculation of total expression in order to correct for total cell RNA content, therefore we will only use endogenous genes. scater performs this normalisation by default, you can control it by changing exprs_values
parameter to "exprs"
.
Another method is called TMM is the weighted trimmed mean of M-values (to the reference) proposed by Robinson and Oshlack (2010), where the weights are from the delta method on Binomial data.
Another very popular method RLE is the scaling factor method proposed by Anders and Huber (2010). We call it “relative log expression”, as median library is calculated from the geometric mean of all columns and the median ratio of each sample to the median library is taken as the scale factor.
A similar to RLE the upperquartile is the upper-quartile normalization method of Bullard et al (2010), in which the scale factors are calculated from the 75% quantile of the counts for each library, after removing genes which are zero in all libraries. This idea is generalized here to allow scaling by any quantile of the distributions.
Let’s compare all these methods.
12.3.1 Raw
12.3.2 CPM
12.3.3 log2(CPM)
12.3.4 TMM
12.3.5 RLE
12.3.6 Upperquantile
12.4 Interpretation
Clearly, only the CPM normalisation has reduced the effect of the number of detected genes and separated cells by individuals (though very weakly).
12.5 Other methods
Some methods combine library size and fragment/gene length normalization such as:
- RPKM - Reads Per Kilobase Million (for single-end sequencing)
- FPKM - Fragments Per Kilobase Million (same as RPKM but for paired-end sequencing, makes sure that paired ends mapped to the same fragment are not counted twice)
- TPM - Transcripts Per Kilobase Million (same as RPKM, but the order of normalizations is reversed - length first and sequencing depth second)
These methods are not applicable to our dataset since the end of the transcript which contains the UMI was preferentially sequenced. Furthermore in general these should only be calculated using appropriate quantification software from aligned BAM files not from read counts since often only a portion of the entire gene/transcript is sequenced, not the entire length.
However, here we show how these normalisations can be calculated using scater. First, we need to find the effective transcript length in Kilobases. However, our dataset containes only gene IDs, therefore we will be using the gene lengths instead of transcripts. scater uses the biomaRt package, which allows one to annotate genes by other attributes:
Some of the genes were not annotated, therefore we filter them out:
Now we compute the effective gene length in Kilobases by using the end_position
and start_position
fields:
Now we are ready to perform the normalisations:
Plot the results as a PCA plot:TPM normalisation produce a zero-matrix, we are not sure why, it maybe a bug in scater.
12.6 Visualize genes
Now after the normalisation we are ready to visualise the gene expression:
12.6.1 Raw
12.6.2 CPM
12.6.3 log2(CPM)
12.6.4 Upperquantile
12.6.5 FPKM
12.6.6 TPM
12.7 Exercise
Perform the same analysis with read counts of the Blischak data. Use blischak/reads.rds
file to load the reads SCESet object. Once you have finished please compare your results to ours (next chapter).
13 Normalization for library size (Reads)
14 Remove confounders using controls
14.1 Introduction
In the previous chapter we saw that the library size normalisation is able to remove major confounders. Let us see whether further use of the controls (ERCC and MT) can provide us with more insights into the data.
Several methods (eg. BASiCS, scLVM, RUV) have been developed for normalisation using ERCCs using different noise models and different fitting procedures.
We will demonstrate some of the methods starting from the simplest one proposed by Brennecke et al., which identifies genes with significant variation above technical noise (ERCCs).
14.2 Brennecke method
To use the method, we first normalize for library size then calculate the mean and the square coefficient of variation (variation divided by the squared mean expression). A curve is fit for the relationship between these two variables for the ERCC spike-in (subject to just technical variation) then a chi-square test is used to find genes significantly above the curve. This has been provided for you as the Brenneck_getVariableGenes(counts, spikes) function.
## Warning in scRNA.seq.funcs::Brennecke_getVariableGenes(assayData(umi.qc)
## $norm_counts, : Only 21 spike-ins to be used in fitting, may result in poor
## fit.
In the figure above blue points are the ERCC spike-ins. The red curve is the fitted technical noise model and the dashed line is the 95% CI. Pink dots are the genes with significant biological variability after multiple-testing correction. Since our dataset is relatively homogeneous only 148 genes are identified as significantly variable.
14.3 Remove Unwanted Variation
Factors contributing to technical noise frequently appear as “batch effects” where cells processed on different days or by different technicians systematically vary from one another. Removing technical noise and correcting for batch effects can frequently be performed using the same tool or slight variants on it. We will be considering the Remove Unwanted Variation (RUV) method which uses singular value decomposition (similar to PCA) on subsets of the dataset which should be invariant (e.g. ERCC spike-ins). Then the method removes the identified unwanted factors.
14.4 Effectiveness 1
We evaluate the effectiveness of the normalization by inspecting the PCA plot where shape corresponds the technical replicate and colour corresponds to different biological samples (individuals from whom the iPSC lines where derived). Separation of biological samples and interspersed batches indicates that technical variation has been removed.
14.5 Effectiveness 2
We can also examine the relative log expression (RLE) across cells to confirm technical noise has been removed from the dataset.
14.6 Exercise
Perform the same analysis with read counts of the Blischak data. Use blischak/reads.rds
file to load the reads SCESet object. Once you have finished please compare your results to ours (next chapter). Additionally, experiment with other combinations of normalizations and compare the results.
15 Remove confounders using controls (Reads)
## Warning in scRNA.seq.funcs::Brennecke_getVariableGenes(assayData(reads.qc)
## $norm_counts, : Only 17 spike-ins to be used in fitting, may result in poor
## fit.
## Warning in xy.coords(x, y, xlabel, ylabel, log): 7 x values <= 0 omitted
## from logarithmic plot


Compound interest is either your best friend or your enemy. Here's how to make it work for you.
by Clint Proctor- Compound interest is the process of adding interest to a principal amount and basing future interest on this new balance.
- Unlike compound interest, simple interest uses only the principal amount to calculate interest.
- While many instalment loans charge simple interest, credit cards use compound interest.
- Read more coverage from How to Do Everything: Money
Compound interest can be one of the most beneficial or damaging things to your wallet. And it all depends on whether you’re earning it or paying it.
When you’re earning compound interest, you could end up with a far larger balance than you initially invested. But when you’re being charged compound interest, you could end up paying far more than you ever borrowed.
But what is compound interest anyway? How does it work and how does it differ from simple interest? Let’s take a look.
What is compound interest?
Compound interest is the process of adding interest to a principal amount and basing future interest on this new balance. Here’s how it works.
Imagine that you invest $US100,000 in the stock market and in year one, you earn a 10% return. That would be $US10,000 in growth, increasing your overall portfolio value to $US110,000.
Then, in year two, you earn another 10%. But, remember, now you’re earning 10% of $US110,000 instead of $US100,000. So you’d actually earn $US11,000 in interest in year two, bringing your account value to $US121,000.
That may not seem like a big difference. But compound interest continues to gain steam over time. Each year, you’d earn slightly more interest on a slightly larger balance. In fact, at a 10% annual return, compound interest would help your account grow to over $US1 million in just 25 years.
And that’s without making any additional contributions during the entire 25-year span.
How compound interest compares to simple interest
Now, let’s take the same example from above and imagine that you were paid with simple interest instead.
If you earned 10% simple interest, you’d earn $US10,000 each year over the course of 25 years – you’d only ever earn interest on your principal investment.
So over 25 years, you’d earn $US225,000 in simple interest. After adding that to your initial $US100,000 balance, you’d find your final balance to be $US350,000.
That’s over $US650,000 less than what you’d have if your interest had compounded all along the way.
Thankfully, most investments use compound interest. On the other hand, simple interest is most commonly used on instalment loans, like mortgages and car loans.
That’s generally good news. But there are situations where you could be charged compound interest on debt, which we’ll discuss later.
How often is interest compounded?
The amount that you earn (or pay) with compound interest is influenced greatly by the compounding frequency.
When you’re comparing CDs or high-yield savings accounts, for example, you could see a variety of compounding schedules, such as daily, monthly, or semi-annually
The more frequent the schedule, the more compound interest you’ll earn over time. So an investment product with a slightly lower interest rate could still be more valuable to you over time if the compounding schedule is more frequent.
To help you determine the true value of compound interest over time, you’ll need a way to calculate it. We’ll discuss how to do that next.
How to calculate compound interest
Not a fan of maths? That’s OK.
You don’t have to calculate compound interest with pen and paper. There are plenty of tools available that can help you calculate compound interest in a matter of seconds.
For instance, Investor.gov has a compound interest calculator that’s simple and easy to use. Simply input your principal balance, estimated interest rate, and length of time, and the compound interest calculator can show you immediate results.
Do you plan to continue making regular contributions over time? The compound interest calculator can take that into account as well.
The compound interest formula
If you’re ambitious and would like to make the calculations yourself, here is the compound interest formula:
FV = PV x (1 +i)n
In this formula, FV means Future Value, PV means Present Value, i means interest rate, and n means number of compounding periods.
So let’s say you wanted to calculate your compound interest earnings on a $US10,000 investment earning 5% interest compounded annually over five years. Here’s how that would be expressed in the above formula.
- FV = $US10,000 x (1 +0.05)5
- FV = $US10,000 x 1.055
- FV = $US10,000 x 1.2762
- FV = $US12,762.00
Another quick way to calculate your compound interest return is by using the Rule of 72. This rule shows you how quickly you can expect your investment to double over time.
It’s easy to use the Rule of 72. Just divide the number 72 by your expected interest rate. So if 6% was your expected rate of return, you could reasonably expect your investment to double every 12 years (72 divided by 6 = 12).
How to avoid paying compound interest
Earning compound interest is great. But paying compound interest is anything but. In fact, it can have disastrous effects on your finances.
As mentioned earlier, most large loans, like auto loans and mortgages, use simple interest formulas. However, there is one kind of debt that does use compound interest: credit cards.
Most credit card issuers compound interest on a daily basis. That interest will begin to accrue the day you make a purchase with your credit card.
However, the good news is that most credit card issuers will give you a grace period up until your due date. In other words, if you pay your statement balance in full by the due date, they will waive the interest charges. But interest will be assessed to any portion of the balance that is left unpaid.
So if you don’t want to pay compound interest, you’ll want to avoid carrying a credit card balance beyond your due date whenever possible.


Before Change
cwd=app_path)
// Do not run with retries since it masks errors
util.run([kfctl_path, "apply", "-V", "all"], cwd=app_path)
verify_kubeconfig(app_path)
if __name__ == "__main__":
After Change
logging.info("Using app path %s", app_path)
zone = "us-central1-a"
os.environ["ZONE"] = zone
if not zone:
raise ValueError("Could not get zone being used")
// We need to specify a valid email because
// 1. We need to create appropriate RBAC rules to allow the current user
// to create the required K8s resources.
// 2. Setting the IAM policy will fail if the email is invalid.
email = util.run(["gcloud", "config", "get-value", "account"])
os.environ["EMAIL"] = email
if not email:
raise ValueError("Could not determine GCP account being used.")
os.environ["PROJECT"] = project
if not project:
raise ValueError("Could not get project being used")
// username and password are passed as env vars and won"t appear in the logs
//
config_spec = get_config_spec(config_path, project, email)


public static final class R.string
extends java.lang.Object
| Constructor and Description |
|---|
R.string() |
public static final int abc_action_bar_home_description
public static final int abc_action_bar_home_description_format
public static final int abc_action_bar_home_subtitle_description_format
public static final int abc_action_bar_up_description
public static final int abc_action_menu_overflow_description
public static final int abc_action_mode_done
public static final int abc_activity_chooser_view_see_all
public static final int abc_activitychooserview_choose_application
public static final int abc_search_hint
public static final int abc_searchview_description_clear
public static final int abc_searchview_description_query
public static final int abc_searchview_description_search
public static final int abc_searchview_description_submit
public static final int abc_searchview_description_voice
public static final int abc_shareactionprovider_share_with
public static final int abc_shareactionprovider_share_with_application
public static final int abc_toolbar_collapse_description
public static final int accept
public static final int action_settings
public static final int action_sign_in
public static final int action_sign_in_short
public static final int activity_add_or_edit_trinket_accessibility_checkbox
public static final int activity_add_or_edit_trinket_description_hint
public static final int activity_add_or_edit_trinket_latitude
public static final int activity_add_or_edit_trinket_longitude
public static final int activity_add_or_edit_trinket_name_hint
public static final int activity_add_or_edit_trinket_picture_library_button_text
public static final int activity_add_or_edit_trinket_quantity_hint
public static final int activity_add_or_edit_trinket_remove_picture_button_text
public static final int activity_add_or_edit_trinket_save_button_text
public static final int activity_add_or_edit_trinket_spinner_categories_prompt
public static final int activity_add_or_edit_trinket_spinner_qualities_prompt
public static final int activity_add_or_edit_trinket_take_picture_button_text
public static final int activity_create_trade_friend_prompt
public static final int activity_display_inventory_category_prompt
public static final int activity_home_page_friends_button
public static final int activity_home_page_inventory_button
public static final int activity_home_page_profile_button
public static final int activity_home_page_trades_button
public static final int app_name
public static final int auth_google_play_services_client_facebook_display_name
public static final int auth_google_play_services_client_google_display_name
public static final int cast_notification_connected_message
public static final int cast_notification_connecting_message
public static final int cast_notification_disconnect
public static final int common_android_wear_notification_needs_update_text
public static final int common_android_wear_update_text
public static final int common_android_wear_update_title
public static final int common_google_play_services_api_unavailable_text
public static final int common_google_play_services_enable_button
public static final int common_google_play_services_enable_text
public static final int common_google_play_services_enable_title
public static final int common_google_play_services_error_notification_requested_by_msg
public static final int common_google_play_services_install_button
public static final int common_google_play_services_install_text_phone
public static final int common_google_play_services_install_text_tablet
public static final int common_google_play_services_install_title
public static final int common_google_play_services_invalid_account_text
public static final int common_google_play_services_invalid_account_title
public static final int common_google_play_services_needs_enabling_title
public static final int common_google_play_services_network_error_text
public static final int common_google_play_services_network_error_title
public static final int common_google_play_services_notification_needs_update_title
public static final int common_google_play_services_notification_ticker
public static final int common_google_play_services_sign_in_failed_text
public static final int common_google_play_services_sign_in_failed_title
public static final int common_google_play_services_unknown_issue
public static final int common_google_play_services_unsupported_text
public static final int common_google_play_services_unsupported_title
public static final int common_google_play_services_update_button
public static final int common_google_play_services_update_text
public static final int common_google_play_services_update_title
public static final int common_google_play_services_updating_text
public static final int common_google_play_services_updating_title
public static final int common_open_on_phone
public static final int common_signin_button_text
public static final int common_signin_button_text_long
public static final int create_calendar_message
public static final int create_calendar_title
public static final int decline
public static final int error_field_required
public static final int error_invalid_email
public static final int google_maps_key
public static final int hello_world
public static final int mr_media_route_button_content_description
public static final int mr_media_route_chooser_searching
public static final int mr_media_route_chooser_title
public static final int mr_media_route_controller_disconnect
public static final int mr_media_route_controller_pause
public static final int mr_media_route_controller_play
public static final int mr_media_route_controller_settings_description
public static final int mr_media_route_controller_stop
public static final int mr_system_route_name
public static final int mr_user_route_category_name
public static final int permission_rationale
public static final int prompt_email
public static final int status_bar_notification_info_overflow
public static final int store_picture_message
public static final int store_picture_title
public static final int test_email
public static final int title_activity_add_or_edit_trinket
public static final int title_activity_all_friends_inventories
public static final int title_activity_counter_trade
public static final int title_activity_create_trade
public static final int title_activity_display_friends_profile
public static final int title_activity_display_tracked_friends
public static final int title_activity_edit_friends_list
public static final int title_activity_edit_profile
public static final int title_activity_friends
public static final int title_activity_friends_inventory
public static final int title_activity_friends_profile
public static final int title_activity_friends_trinket_details
public static final int title_activity_home_page
public static final int title_activity_inventory
public static final int title_activity_inventory_details
public static final int title_activity_inventory_trade
public static final int title_activity_maps
public static final int title_activity_past_trades
public static final int title_activity_tracked_friends
public static final int title_activity_trade_details
public static final int title_activity_trade_received
public static final int title_activity_trades
public static final int title_activity_trinket_details
public static final int title_activity_user_profile
public static final int wallet_buy_button_place_holder


Some of Our Favorite Mapzen Search Projects of 2015
It’s been an exciting year for Mapzen Search and for our users, so we thought today would be a great time to look back at some of the most exciting things you’re doing with Mapzen Search!
Mapillary
Our friends at Mapillary have been using Mapzen Search to help with their crowdsourced mission of photographing every public place. Mapillary’s amazing community of photomappers have biked, driven, and walked over 1 million kilometers taking photos of the world to build a crowdsourced “Street View”. And searching those views is easier than ever, now that Mapzen Search powers the location search on their website and their iPhone app!
Gaia GPS
As one of the earliest adopters of Mapzen Search, Gaia GPS has been pioneering new uses for the tool for months! Since we’ve been in beta, Gaia GPS has been helping hikers, bikers, and other outdoor explorers remember their outdoor adventures, using our reverse geocoding to name their custom trails.
| Grocery Points of Interest* | with Addresses | with Website | with Hours | |
|---|---|---|---|---|
| Auckland | 337 | 6% | 1% | 1% |
| Dublin | 690 | 14% | 4% | 5% |
| Hong Kong | 496 | 6% | 1% | 3% |
| Melbourne | 220 | 35% | 30% | 17% |
| Mexico City | 702 | 8% | 1% | 6% |
| Mumbai | 119 | 7% | 2% | 2% |
| San Francisco | 715 | 47% | 18% | 15% |
| São Paulo | 806 | 22% | 6% | 3% |
| Seoul | 1,069 | 2% | 0.3% | 1% |
| Singapore | 343 | 12% | 6% | 5% |
| Stockholm | 673 | 18% | 17% | 34% |
| Vancouver | 193 | 38% | 11% | 11% |
They just rolled the feature out into their iOS app, so if you’re planning an outdoor adventure and want to plan or log your journey, know that Mapzen Search is there to help you find yourself in GaiaGPS.
Meshu
Meshu is artisanal map art jewelry commerce at its finest. Meshu is the brainchild of Rachel Binx, a self-described “data visualizer, art historian, mathematician, and GIF empress,” and lets people create custom jewelry from the geodata of places they’ve visited.
We seriously <3 Meshu (and its sister projects monochōme and TrekNotes) and love seeing our tools powering awesome map art. Make more!
CAD Mapper
CAD Mapper is one of those remarkable small businesses that builds on top of OpenStreetMap and makes a point of giving back to the community. CAD Mapper allows architects and designers who work with CAD tools, like Autodesk’s venerable AutoCAD or the open source QCAD, to pull custom geographic data from OpenStreetMap into their existing tools.
They’ve been using our autocomplete plugin for Leaflet to let users search for areas of interest to export.
CAD Mapper also provides a CAD-friendly version of Metro Extracts, providing free AutoCAD DXF models of entire cities from OpenStreetMap!
Missed Your Project?
There have been hundreds of folks who’ve given Mapzen Search a try this year and we were only able to highlight a few of them. But if you’ve got a project we should know about, drop us a line and we’ll try to showcase it in our next roundup.
Thanks so much for searching with us in 2015. We hope to find a lot more with you in 2016!
intro GIF via gifpop.io


Gammatone-like spectrograms
Gammatone filters are a popular linear approximation to the filtering performed by the ear. This routine provides a simple wrapper for generating time-frequency surfaces based on a gammatone analysis, which can be used as a replacement for a conventional spectrogram. It also provides a fast approximation to this surface based on weighting the output of a conventional FFT.
Contents
Introduction
It is very natural to visualize sound as a time-varying distribution of energy in frequency - not least because this is one way of describing the information our brains get from our ears via the auditory nerve. The spectrogram is the traditional time-frequency visualization, but it actually has some important differences from how sound is analyzed by the ear, most significantly that the ear's frequency subbands get wider for higher frequencies, whereas the spectrogram has a constant bandwidth across all frequency channels.
There have been many signal-processing approximations proposed for the frequency analysis performed by the ear; one of the most popular is the Gammatone filterbank originally proposed by Roy Patterson and colleagues in 1992. Gammatone filters were conceived as a simple fit to experimental observations of the mammalian cochlea, and have a repeated pole structure leading to an impulse response that is the product of a Gamma envelope g(t) = t^n e^{-t} and a sinusoid (tone).
One reason for the popularity of this approach is the availability of an implementation by Malcolm Slaney, as described in:
Malcolm Slaney (1998) "Auditory Toolbox Version 2", Technical Report #1998-010, Interval Research Corporation, 1998. http://cobweb.ecn.purdue.edu/~malcolm/interval/1998-010/
Malcolm's toolbox includes routines to design a Gammatone filterbank and to process a signal by every filter in a bank, but in order to convert this into a time-frequency visualization it is necessary to sum up the energy within regular time bins. While this is not complicated, the function here provides a convenient wrapper to achieve this final step, for applications that are content to work with time-frequency magnitude distributions instead of going down to the waveform levels. In this mode of operation, the routine uses Malcolm's MakeERBFilters and ERBFilterBank routines.
This is, however, quite a computationally expensive approach, so we also provide an alternative algorithm that gives very similar results. In this mode, the Gammatone-based spectrogram is constructed by first calculating a conventional, fixed-bandwidth spectrogram, then combining the fine frequency resolution of the FFT-based spectra into the coarser, smoother Gammatone responses via a weighting function. This calculates the time-frequency distribution some 30-40x faster than the full approach.
Routines
The code consists of a main routine, gammatonegram, which takes a waveform and other parameters and returns a spectrogram-like time-frequency matrix, and a helper function fft2gammatonemx, which constructs the weighting matrix to convert FFT output spectra into gammatone approximations.
Example usage
First, we calculate a Gammatone-based spectrogram-like image of a speech waveform using the fast approximation. Then we do the same thing using the full filtering approach, for comparison.
% Load a waveform, calculate its gammatone spectrogram, then display: [d,sr] = wavread('sa2.wav'); tic; D = gammatonegram(d,sr); toc %Elapsed time is 0.140742 seconds. subplot(211) imagesc(20*log10(D)); axis xy caxis([-90 -30]) colorbar title('Gammatonegram - fast method') % Now repeat with flag to use actual subband filters. % Since it's the last argument, we have to include all the other % arguments. These are the default values for: summation window % (0.025 sec), hop between successive windows (0.010 sec), % number of gammatone channels (64), lowest frequency (50 Hz), % and highest frequency (sr/2). The last argument as zero % means not to use the FFT approach. tic; D2 = gammatonegram(d,sr,0.025,0.010,64,50,sr/2,0); toc %Elapsed time is 3.165083 seconds. subplot(212) imagesc(20*log10(D2)); axis xy caxis([-90 -30]) colorbar title('Gammatonegram - accurate method') % Actual gammatone filters appear somewhat narrower. The fast % version assumes coherence of addition of amplitude from % different channels, whereas the actual subband energies will % depend on how the energy in different frequencies combines. % Also notice the visible time smearing in the low frequency % channels that does not occur in the fast version.
Validation
We can check the frequency responses of the filterbank simulated with the fast method against the actual filters from Malcolm's toolbox. They match very closely, but of course this still doesn't mean the two approaches will give identical results - because the fast method ignores the phase of each frequency channel when summing up.
% Check the frequency responses to see that they match: % Put an impulse through the Slaney ERB filters, then take the % frequency response of each impulse response. fcfs = flipud(MakeERBFilters(16000,64,50)); gtir = ERBFilterBank([1, zeros(1,1000)],fcfs); H = zeros(64,512); for i = 1:64; H(i,:) = abs(freqz(gtir(i,:),1,512)); end % The weighting matrix for the FFT is the frequency response % of each output filter gtm = fft2gammatonemx(1024,16000,64,1,50,8000,512); % Plot every 5th channel from both. Offset by 3 dB just so we can % see both fs = [0:511]/512*8000; figure plot(fs,20*log10(H(5:5:64,:))','b',fs, -3 + 20*log10(gtm(5:5:64,:))','r') axis([0 8000 -150 0]) grid % Line up pretty well, apart from wiggles below -100 dB % (from truncating the impulse response at 1000 samples?)
Download
You can download all the code and data for these examples here: gammatone.tgz.
Acknowledgment
This project was supported in part by the NSF under grant IIS-0535168. Any opinions, findings and conclusions or recommendations expressed in this material are those of the authors and do not necessarily reflect the views of the Sponsors.
% Last updated: $Date: 2009/02/22 01:46:42 $ % Dan Ellis <dpwe@ee.columbia.edu>


Paste your thread dump here:
This page is client-side only, and no data will leave your computer when you click Analyze.
Report a bug
See TODO list for which of these there are plans for already:


{{policy.id}}
{{policy.gp_id}}
{{policy.group_policy_id}}
{{policy.phone_no}}
{{currency policy.premium_amount policy}}
{{currency policy.sum_insured_amount policy}}
{{array2table policy.payments policy}}
{{policyPayouts policy.claims policy}}
{{json2table policy.meta policy}}
{{policy.bc.next_action}}
{{bcAuditTrail policy.bc policy}}


|
G24Lib
A set of convenient classes, functions and other utilities mainly for quickly writing numerical code. Provides relatively easy integration with CUDA, general Runge-Kutta methods, linear equation solvers and more.
|
Provides a base class for all memory managers. More...
Public Types | |
| using | indexer_type = indexer |
| using | managed_type = Type |
| using | memory_location = void |
| The memory context in which this manager allocates and deallocates the requested memory. More... | |
Static Public Member Functions | |
| static Type * | allocate (const indexer num) |
Allocates num objects of type Type . More... | |
| static constexpr CUDA_HOS_DEV bool | can_operate () |
| A quick way to check if the managed memory can be safely operated on in the current context. More... | |
| template<class other_manager > | |
| static void | copy (Type *dest, const Type *source, const indexer num) |
Copies num objects from array pointed by source to array in dest . More... | |
| static void | copy_from_normal_memory (Type *dest, const Type *source, const indexer num) |
Copies num objects from array that resides in normal memory pointed by source to array in dest . More... | |
| static void | copy_to_normal_memory (Type *dest, const Type *source, const indexer num) |
Copies num objects from array pointed by source to array in dest that resides in normal memory. More... | |
| static void | deallocate (Type *&arr, const indexer num) |
Deallocates num objects of type Type residing in an array pointed by arr and sets arr to nullptr . More... | |
| static constexpr std::string_view | manager_name () |
An identifier for this memory manager, mainly for debug outputs enabled by g24_lib::Definitions::print_memory_debug_info . More... | |
| template<class other_manager > | |
| static void | move (Type *&dest, Type *&source, const indexer old_num, const indexer new_num) |
Moves num objects from array pointed by source to array in dest . Deallocates source and puts it to nullptr . More... | |
Provides a base class for all memory managers.
| Type | The type of the object being managed. |
| indexer | A type that is appropriate to hold sizes of objects. |
indexer
must satisfy the constraints placed on the choice of g24_lib::Definitions::default_unsigned_indexer.Definition at line 130 of file memory_manager.h.
| using g24_lib::memory_manager_base< Type, indexer >::indexer_type = indexer |
Definition at line 134 of file memory_manager.h.
| using g24_lib::memory_manager_base< Type, indexer >::managed_type = Type |
Definition at line 132 of file memory_manager.h.
| using g24_lib::memory_manager_base< Type, indexer >::memory_location = void |
The memory context in which this manager allocates and deallocates the requested memory.
Definition at line 139 of file memory_manager.h.
|
inlinestatic |
Allocates num
objects of type Type
.
Definition at line 164 of file memory_manager.h.
|
inlinestaticconstexpr |
A quick way to check if the managed memory can be safely operated on in the current context.
Definition at line 144 of file memory_manager.h.
|
inlinestatic |
Copies num
objects from array pointed by source
to array in dest
.
source
must be a pointer previously allocated by other_manager
.dest
must be a pointer previously allocated by this manager. Definition at line 188 of file memory_manager.h.
|
inlinestatic |
Copies num
objects from array that resides in normal memory pointed by source
to array in dest
.
source
must be a pointer that resides in normal memory (either allocated with new
or through g24_lib::default_memory_manager
).dest
must be a pointer previously allocated by this manager. Definition at line 214 of file memory_manager.h.
|
inlinestatic |
Copies num
objects from array pointed by source
to array in dest
that resides in normal memory.
source
must be a pointer previously allocated by this manager.dest
must be a pointer that resides in normal memory (either allocated with new
or through g24_lib::default_memory_manager
). Definition at line 201 of file memory_manager.h.
|
inlinestatic |
Deallocates num
objects of type Type
residing in an array pointed by arr
and sets arr
to nullptr
.
arr
must be a pointer previously allocated by this manager. Definition at line 176 of file memory_manager.h.
|
inlinestaticconstexpr |
An identifier for this memory manager, mainly for debug outputs enabled by g24_lib::Definitions::print_memory_debug_info
.
Definition at line 153 of file memory_manager.h.
|
inlinestatic |
Moves num
objects from array pointed by source
to array in dest
. Deallocates source
and puts it to nullptr
.
source
must be a pointer previously allocated by other_manager
.dest
must be a pointer previously allocated by this manager. Definition at line 228 of file memory_manager.h.


R&D Bioinformatics Scientist, NGS - San Francisco, CA 94158
The R&D Bioinformatics Scientist, NGS will be an addition to the bioinformatics and genomics capability within Twist R&D and will play a key role in expanding Twist's Next-Generation Sequencing product portfolio. The R&D NGS team designs and develops Next-Generation Sequencing-based methods, applications and panels, and works with other departments within Twist to cover all aspects of products from concept to development to commercial launch. The ideal candidate will have a strong domain knowledge in genomics, excellent programming skills, and have experience applying that knowledge with next generation sequencing.
The successful candidate will be responsible for:
Collaborating with scientists and research associates in all phases of R&D work including experimental design, data analysis, and data interpretation/troubleshooting.
Performing panel design and analysis for the development of NGS products and applications read alignment, targeted sequencing, mapping, annotation, and variant calling.
Writing and packaging off-the-shelf scripts into custom pipelines for NGS data analysis, enabling data analysis by non-bioinformaticians
Communicating internally with other departments and externally with customers and collaborators about technological capabilities through direct interactions and collateral.
Requirements:
M.S. or Ph.D. degree in Genetics, Biology, Bioinformatics, Biostatistics, Computational Biology, Computer Science, or related field
Experience in one or more of the following: cancer, viral, or rare disease genomics, haplotype and variant inference, cell-free DNA sequencing, methylation sequencing, single cell sequencing.
Proficiency in python, ruby, perl, or another high-level scripting language (python highly preferred)
Deep understanding of next generation sequencing methods, genome structure, platform-specific bias and errors, and data interpretation
Hands-on experience with large-scale genomic data (e.g. whole genome sequencing, exome-seq, target enrichment, amplicon sequencing, RNA-seq, etc.)
Excellent understanding of short-read alignment, mapping, variant calling of diverse types of genomic variation, and annotation tools
Familiarity with human and mammalian genomics, standard genomic databases (UCSC, Ensembl, NCBI), formats, and tools.
Familiarity with UNIX-based operating systems and shell scripting
Excellent data analysis and visualization skills (Tableau, R, matplotlib, or similar)
Excellent understanding of molecular biology and cell biology
Strong interpersonal communication skills
Excellent publication track record
Additional desired qualities include:
Familiarity with version control (git, subversion)
Experience with target enrichment
Experience in clinical laboratory testing
Experience with Seven Bridges, DNA Nexus or similar platform
About Twist Bioscience
Twist Bioscience synthesizes genes from scratch, known as "writing" DNA. Just as children learn to both read and write, the next phase of development for the genomics revolution is the ability to write DNA.
At Twist Bioscience, we work in service of people who are changing the world for the better. In fields such as health care, agriculture, industrial chemicals and data storage, our unique silicon-based DNA Synthesis Platform provides precision at a scale that is otherwise unavailable to our customers.
Twist Bioscience Corporation is an Equal Opportunity Employer. Twist Bioscience Corporation provides equal employment opportunities to all employees and applicants for employment without regard to race, color, religion, sex, sexual orientation, gender identity, national origin, age, disability, genetic characteristics, or any other category protected by law.
San Francisco applicants: Pursuant to the San Francisco Fair Chance Ordinance, we will consider for employment qualified applicants with arrest and conviction records.


RT @yukihiro_matz: link: Have Static Languages Won? | Pointers Gone Wild:
http://pointersgonewild.com/2015/11/25/have-static-languages-won/
11/27/2015, 11:01:00 AM
Favs: 0
Retweets: 0
link--- layout: tweet ---
RT @yukihiro_matz: link: Have Static Languages Won? | Pointers Gone Wild:
http://pointersgonewild.com/2015/11/25/have-static-languages-won/
11/27/2015, 11:01:00 AM
Favs: 0
Retweets: 0
link


| ConstantFuture-class {future} | R Documentation |
A constant future is a future whose expression is a constant and therefore by definition is already resolved upon creation.
ConstantFuture(..., globals = TRUE, envir = emptyenv())
... |
Additional named elements of the future. |
globals |
(optional) a logical, a character vector, or a named list
to control how globals are handled.
For details, see section 'Globals used by future expressions'
in the help for |
envir |
The environment from where global objects should be identified. |
An object of class ConstantFuture
.


NOW OPEN DINE IN
4133 University Way Northeast
Seattle WA 98105
Open Sun 12PM to 11PM
Open Mon-Thurs 12PM to 12AM
Open Fri - Sat 12PM to 1AM
Phone:<PHONE_NUMBER>
For sales inquiries please contact at: sales@bigtimebrewery.com


Region 5 ESC welcomes you to the 2014 Textbook Fair for Science, Math (K-8), and Technology Applications (2014-15 adoption).
The Textbook Fair will be held Tuesday, January 14, 2014 on the 4th floor at Edison Plaza, 350 Pine Street, Beaumont, Texas from 8:30- 4:00 P.M.
Admission is free and open to any school district personnel.
There is no registration but attendants will need to pick up a badge when they enter the building.
Textbook publishers will be holding break-out sessions to showcase their offerings for all subjects.
The publishers will have booths outside of the presentation rooms where you may speak with the textbook representatives personally and gather information.


We are a full-stack web and app development team focused on making mobile devices usable, useful, and fun.
The Docket is an app we have been working on.
You can email us here
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Praesent mattis nunc vitae rutrum molestie. Nulla sem enim, dapibus vel luctus at, fermentum id nisl. Sed nulla orci, sollicitudin vel leo quis, condimentum ullamcorper mauris. Praesent laoreet gravida arcu, at fringilla urna pellentesque ac. Aliquam


 It's hard to make a good movie, but to make a movie that's a failure on every single imaginable level is, in some ways, tougher. It's very difficult to get this many people, all at once, to abdicate any of quality work.
"Virus" plays like a rip-off of both "Deep Rising", another terrible movie from last year, and any of the "Star Trek" episodes that feature the Borg. It starts off with some kind of space cloud "infecting" a Russian orbital station and using the station's antenna to send some kind of computer virus to a communications ship in the ocean below. The virus appears to want to take over humanity, or something, but its methodologies and M.O.s are never clear.
Anyway, the aforementioned ship gets discovered by a tug crewed by Kit Foster (Jamie Lee Curtis) and Steve Baker (William Baldwin). The tug's captain (Donald Sutherland, doing one of his wacko roles) wants to claim the ship for salvage, but it isn't long before they discover Something's Not Right Here. The ship's steering itself, for starters. In such circumstances, the characters are advised to find the screenwriter and beat him to death for the crime of rampant laziness and unoriginality.
It gets worse. The virus manages to build robot incarnations of itself and use those to transform the crew members into things that look like rejected test reels for the Cenobites from "Hellraiser". The master creature is laughingly reminiscent of a Pop Art junk sculpture, and looks about as threatening. It drills through bulkheads and barks out idiotic pulp-movie dialogue in a voice that sounds like my car's "Your door is ajar" warning on very bad drugs.
According to the movie's press kit, the movie was drawn from a Dark Horse comic series with the same name. Dark Horse is a comic imprint that specializes in strong, compelling stories. My guess is that they liposuctioned the story out of the comic before filming it.
-----------== Posted via Deja News, The Discussion Network ==---------- http://www.dejanews.com/ Search, Read, Discuss, or Start Your Own
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


You can stop trying to figure out the worst film of the year right now.  It is simply the laziest script ever written, full of things that make absolutely no sense, refusing to even adhere to it's own sense of idiotic logic. It's the story of a professor who is trying to invent an anti-gravity polymer. He's so absent minded that he has missed his own wedding three times. His best pal is a little floating mechanical device with a video screen that flies around the house helping him out and giving him advice. Did you hear that? He has ALREADY INVENTED a device that can fly around of it's own accord, yet we're supposed to go EUREKA when he gets his car to fly.  Can you believe we're supposed to get involved with a man who is desperately trying to create something he has already created? John Hughes thinks we're idiots. Once flubber is invented, the film continues to violate every single rule of decent screenwriting. The flubber does all kinds of crazy things that have absolutlely nothing to do with the plot of the film. At one point, when no one is looking, the flubber breaks itself into hundreds of pieces and does an enormous Carmen Miranda musical number. How does a piece of FLying rUBBER know how to do this? WHY would a piece of FLying rUBBER do this? Who cares? The scene is there because it is there. Cut it out and the film doesn't change at all. Cut out just about every single scene where the flubber does something supposedly funny and it doesn't effect the plot at all. The first thing that the professor does with the flubber is put it on a golf ball. It bounces around his laboratory destroying everything in its path. What's the next thing the professor does? He puts the flubber on a bowling ball. We laugh in anticipation of the havoc it will wreak.   Later, his little floating mechanical pal gets smashed. What does he do? He cries. This is the single most embarrassing moment of Robin Williams carreer. He doesn't cry when his bride abandons him. He cries when his little toy breaks. A toy he built. A toy he can easily rebuild. I could go on and on but I won't. The film doesn't deserve analysis. It deserves immolation.
MD
********************************** THE ONE AND ONLY DARENET SIGFILE http://home.earthlink.net/~dare2b/
Be there or don't **********************************
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


In a correctly designed system, a plain password is not stored in the database. Instead, a hash of the password is stored. You are going to verify a password and you will need to use the same one-way function to calculate the hash and do a comparison.
Input: Two string arguments. One is the string to be hashed, another is the hash algorithm.
Output: String, hexadecimal hash for for input string using given algorithm
Example:
assert checkio(b'welcome', 'md5') == '40be4e59b9a2a2b5dffb918c0e86bhe3d7' assert checkio(b'happy spam', 'sha224') == '6e9dc3e01d57f1598c2b40ce59fc3527e698c77b15d0840ae96a8b5e'


Package org.apache.cayenne.reflect
-
Interface Summary Interface Description Accessor An accessor of a property value.AccessorFactory ArcProperty A Property that represents an "arc" connecting source node to the target node in the graph.AttributeProperty Represents a simple object property.ClassDescriptor A runtime descriptor of an persistent class.ClassDescriptorFactory A factory ofClassDescriptor
instances.EmbeddableDescriptor FaultFactory Property Deprecated. since 4.0 renamed to PropertyDescriptor.PropertyDescriptor Defines bean property API used by Cayenne to access object data, do faulting and graph maintenance tasks.PropertyVisitor A visitor for various types of properties in a ClassDescriptor.ToManyMapProperty A property representing a map of objects keyed by one of the object properties.ToManyProperty A property representing a collection of objects.ToOneProperty An ArcProperty that points to a single graph node. -
Class Summary Class Description BaseArcProperty A base implementation of theArcProperty
.BaseProperty An abstract property descriptor that delegates property access to anAccessor
.BaseToManyProperty A generic superclass of CollectionProperty implementations.BaseToOneProperty A convenience base superclass forToOneProperty
implementors.BeanAccessor A property accessor that uses set/get methods following JavaBean naming conventions.ClassDescriptorMap An object that holds class descriptors for mapped entities, compiling new descriptors on demand using an internal chain of descriptor factories.Converter<T> A helper class to do property type conversions.ConverterFactory A factory of property type converters.EmbeddedFieldAccessor An accessor for fields storing embedded objects.FieldAccessor A PropertyAccessor that performs direct Field access.FieldEmbeddableDescriptor A default POJO embeddable descriptor.IdMapKeyAccessor A stateless read-only accessor of the map key value that is based on the Persistent object id.LazyClassDescriptorDecorator A ClassDescriptor wrapper that compiles decorated descriptor lazily on first access.LifecycleCallbackRegistry A registry of lifecycle callbacks for all callback event types.MapAccessor PersistentDescriptor A default ClassDescriptor implementation for persistent objects.PersistentDescriptorFactory A convenience superclass forClassDescriptorFactory
implementors.PropertyAccessor A utility accessor class that wraps a simple property.PropertyUtils Utility methods to quickly access object properties.SimpleAttributeProperty A descriptor of an "attribute" persistent property.SingletonFaultFactory ToAnyConverter<T> Can convert to any class that has a constructor that takes a single Object or a single String parameter. -
Exception Summary Exception Description PropertyException An unchecked exception thrown on errors during property access, either within a Accessor or a Property.UnresolvablePathException A runtime exception thrown whenPropertyUtils.getProperty()
finds that there is a null value in middle of the resolved path.


{{ if .Params.slide }}
{{ partial "layout/head" . }} {{ partial "layout/theme" . }} {{ partialCached "head/styles" . }} {{- partial "reveal-hugo/head" . -}} {{- $sectionHeadPartial := printf "%s/reveal-hugo/head" (.Page.Section | default "home") -}} {{- if fileExists (printf "layouts/partials/%s.html" $sectionHeadPartial) -}}{{ partial $sectionHeadPartial . }}{{- end }}


Get to know me!
Hey! It's Zeb and I'm a Full-Stack Developer located in India. I've done remote projects for agencies, startups.
I will build awesome looking websites at the most affordable rates. Feel free to contact me.
Hey! It's Zeb and I'm a Full-Stack Developer located in India. I've done remote projects for agencies, startups.
I will build awesome looking websites at the most affordable rates. Feel free to contact me.
Lorem ipsum dolor sit amet consectetur adipisicing elit. Hic facilis tempora, explicabo quae quod deserunt eius sapiente praesentium.
VisitLorem ipsum dolor sit amet consectetur adipisicing elit. Hic facilis tempora, explicabo quae quod deserunt eius sapiente praesentium.
VisitLorem ipsum dolor sit amet consectetur adipisicing elit. Hic facilis tempora, explicabo quae quod deserunt eius sapiente praesentium.
Visit


Upload Files
New folder
Calculating...
Uploading file name
Type the folder name:
Create
Cancel
Type the new name:
Rename
Cancel
Download
Rename
Delete


HOLY MAN Reviewed by Jamie Peck
Forgive Murphy but not the movie. The comedian's turn as a bald, homeless, robe-clad purveyor of peace, love and happiness is a beatific breath of fresh air, especially on the heels of some delightfully unhinged work in summer's stirring "Mulan" and scatological "Dr. Dolittle." His character is simply called G, and the letter might as well be his rating, too - waiting for Murphy to cut loose in the wild ways that post-"Nutty Professor" crowds crave is ultimately fruitless. In "Holy Man," he doesn't get to fart or cuss or crack wise about sexual functions. It must be that higher plain.
A near-auto mishap puts G's spiritual pilgrimage on hold when, while wandering the highways of Miami, he's almost hit by a Jaguar belonging to harried television executive Ricky Hayman (Jeff Goldblum). Ricky, who works for the struggling, QVC-esque Good Buy Shopping Network, reluctantly allows G to convalesce at his beach-side home, and it's only a matter of time before the recovered prophet winds up on the small screen, hawking junky goods like seasonal doormats and a bidet that sprays its user with "a kiss of refreshing mist."
Here's the twist: G preaches as he pitches, assuring viewers that they would probably be better off _not_ giving into materialistic whims, but people buy big time anyhow. Too bad Murphy's Zenistic life lessons are completely transparent and often play like long-winded set-ups for punchlines that never arrive. The pokes at consumer culture are dead-on, but too often the film brushes aside the funny stuff for surprisingly straight-faced subplots, the eye-rolling pinnacle of which is a romantic sidetrack between Ricky and a cute media analyst (Kelly Preston).
"Holy Man" gets so loaded down with all this unnecessary bunk that it completely loses track of what it set out to spoof - even Murphy disappears for large chunks of the movie's second hour so the focus can be turned to heavy-handed drama, complete with a schmaltzy soundtrack and slow fade-outs. But all is not lost; Murphy and Goldblum make fantastic foils during the limited time they have together, and the film trots out a galaxy of self-depreciating stars to poke some sly fun at celebrity image as they push their products on Good Buy.
There's Morgan Fairchild's fabulous facelift machine and James Brown's ambulance-alerting medical belt that screams, "Help me, help me! Good God!" But the best bit finds ex-Golden Girl Betty White peddling an aphrodisiac scent that makes her climax right there on the air. As for most everything else, buyer - and viewer - beware.
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


{% extends "base.html" %} {% block content %}
Journal-Rank is a place for opinion based reviews of academic journals by readers/authors. There are many popular metrics for ranking journals like citation/ publication count etc., but to my knowledge there is no place for individuals to submit opinion based reviews so I made Journal-Rank to address that.
The database of journals for Journal-Rank was built using information from the following resource:
SCImago, (n.d.). SJR — SCImago Journal & Country Rank [Portal]. Retrieved 12/14/18 , from http://www.scimagojr.com


The ObjectProviders
configuration drives the object
translator. Contributions
define an object provider in terms of a prefix (such as service
)
and a service that implements the ObjectProvider
interface.
Object providers exist to support object references. Object references are a way to contribute objects that may be references to services, or to other objects, or may even be created on the spot. This is often used with the hivemind.BuilderFactory's <set-object> element.
An object reference consists of a prefix and a locator seperated by a colon. The interpretation of the locator is different for each provider. The prefix determines which provider will be utilized to interpret the locator.
The contribution format defines the name and class for each service model:
<provider prefix="..." service-id="..."/>
Prefixes must be unique.
The following default prefixes are available:
| Prefix | Descripton | Example |
|---|---|---|
| bean | The locator is a BeanFactory locator, consisting of the id of a BeanFactory service, a colon, and an optional initializer for the bean. | bean:ValidatorFactory:string,required |
| class | The locator is a class name. It may be a partial class name, with the package name provided by the contributing module. | class:java.util.List |
| configuration | The locator is the id of a configuration. | configuration:MyConfiguration |
| instance | The locator is a class name, which must have a public no arguments contructor. You may use instance initializer syntax. | instance:com.example.MyObject |
| service | The locator is the id of a service. | service:MyService |
| service-property | The locator provides a service id and a property name (provided by that service), seperated with a colon. | service-property:MyService:activeRequest |
| spring | The locator is the name of a bean within a Spring BeanFactory. | spring:MyBean |
Note:
The bean: and spring: prefixes are provided by the HiveMind library (not the base framework).