Input/Output is provided as a public service and is not a commercial product.
The app does not collect any personal information from the authentication providers it uses to authenticate you when you login. We are provided with a unique identifier (which looks something like BzWK4x9dqFgL2r5hbDfTkKnARGm2) and we use that as a key into our database to store your information. No other personal information is collected, not your name, not your email address, not your computer's IP address. Nothing.
Note: when you authenticate using the Google or Facebook auth provider, it will state that Input/Output will receive your name, email address and (in the case of Facebook) profile picture. Unfortunately we cannot request less information about you than this, but we do not use or store any of that information in the app. If we could instruct the auth providers not to provide this information we would, but tragically there is no way to do so. If you are of a technical bent, you can inspect the source code of the app and see that we never access any information from the auth provider aside from the unique identifier assigned to your account.
The app is built using Google's Firebase platform, which means that we rely on Google not to surreptitiously collect data behind the scenes. However, they attest that the Firebase platform is compliant with GDPR and introduces no additional reporting requirements other than those needed by the apps built on its platform. So this is a good indication that they are not storing any data that we are not explicitly asking them to store, and we are not explicitly asking them to store anything that is not completely essential to the operation of the app: your unique identifier and the data you add to the app itself.
The app currently does not use any analytics platform to compute aggregated information about its usage. I have no plans to activate analytics for the app, but if I do so, it will be noted in this privacy policy. As this is not a commercial product, there is no particular need to know even aggregate information about its users.
The app does use cookies for the sole purpose of avoiding the need to log in every single time you access the app. A unique "session" identifier is generated and stored on your web browser to facilitate this process. The session identifier can be linked to your account identifier (as described above) and that's it. The session identifier is necessarily secret and is not stored anywhere except your computer and (temporarily) on the servers. Neither it nor your account identifier are shared with anyone.
None of the data you add to the app is shared with any third party. It is only ever stored on devices you use to access the app and on the cloud servers that host the app. It is not used for advertising or "mined" for other information in any way.
The app relies on the security of the Firebase platform, and the authentication provider you choose, to secure your data. Firebase uses modern best practices for authentication security and backend server security, so we have no reason to believe that the data you store in the Input/Output app is any less secure than all the other major websites you probably use.
If you have questions regarding this privacy policy, please contact me.


--- layout: post title: Hope you like the new look of the PCL blog, let me know. date: '2011-12-18T18:28:00.000-05:00' author: Bob Sica tags: modified_time: '2011-12-21T12:48:50.450-05:00' blogger_id: tag:blogger.com,1999:blog-736339229338318027.post-8983666904731339201 blogger_orig_url: http://blog.purplecrowlidar.ca/2011/12/hope-you-like-new-look-of-pcl-blog-let.html ---
I took some time to day to play around with the look of the blog. I liked this particular theme because it uses the full width of the screen and I managed to make the type readable for my eyes, play with the colors, add some links, "eggs cetera". What do you think?


R and RStudio
What is R?
R is a language and environment for statistical computing and graphics developed in 1993. It provides a wide variety of statistical and graphical techniques (linear and nonlinear modeling, statistical tests, time series analysis, classification, clustering, …), and is highly extensible, meaning that the user community can write new R tools. It is a GNU project (Free and Open Source).
The R language has its roots in the S language and environment which was developed at Bell Laboratories (formerly AT&T, now Lucent Technologies) by John Chambers and colleagues. R was created by Ross Ihaka and Robert Gentleman at the University of Auckland, New Zealand, and now, R is developed by the R Development Core Team, of which Chambers is a member. R is named partly after the first names of the first two R authors (Robert Gentleman and Ross Ihaka), and partly as a play on the name of S. R can be considered as a different implementation of S. There are some important differences, but much code written for S runs unaltered under R.
Some of R’s strengths:
- The ease with which well-designed publication-quality plots can be produced, including mathematical symbols and formulae where needed. Great care has been taken over the defaults for the minor design choices in graphics, but the user retains full control.
- It compiles and runs on a wide variety of UNIX platforms and similar systems (including FreeBSD and Linux), Windows and MacOS.
- R can be extended (easily) via packages.
- R has its own LaTeX-like documentation format, which is used to supply comprehensive documentation, both on-line in a number of formats and in hardcopy.
- It has a vast community both in academia and in business.
- It’s FREE!
The R environment
R is an integrated suite of software facilities for data manipulation, calculation and graphical display. It includes
- an effective data handling and storage facility,
- a suite of operators for calculations on arrays, in particular matrices,
- a large, coherent, integrated collection of intermediate tools for data analysis,
- graphical facilities for data analysis and display either on-screen or on hardcopy, and
- a well-developed, and effective programming language which includes conditionals, loops, user-defined recursive functions and input and output facilities.
The term “environment” is intended to characterize it as a fully planned and coherent system, rather than an incremental accretion of very specific and inflexible tools, as is frequently the case with other data analysis software.
R, like S, is designed around a true computer language, and it allows users to add additional functionality by defining new functions. Much of the system is itself written in the R dialect of S, which makes it easy for users to follow the algorithmic choices made. For computationally-intensive tasks, C, C++ and Fortran code can be linked and called at run time. Advanced users can write C code to manipulate R objects directly.
Many users think of R as a statistics system. The R group prefers to think of it of an environment within which statistical techniques are implemented.
The R Homepage
The R homepage has a wealth of information on it,
R-project.org
On the homepage you can:
- Learn more about R
- Download R
- Get Documentation (official and user supplied)
- Get access to CRAN ‘Comprehensive R archival network’
Interface for R
There are many ways one can interface with R language. Here are a few popular ones:
- RStudio
- RGui
- Jupyter and R notebooks
- text editors, such as vi(m), Emacs…
RStudio
RStudio started in 2010, to offer R a more full featured integrated development environment (IDE) and modeled after matlab’s IDE.
RStudio has many features:
- syntax highlighting
- code completion
- smart indentation
- “Projects”
- workspace browser and data viewer
- embedded plots
- Markdown notebooks, Sweave authoring and knitr with one click pdf or html
- runs on all platforms and over the web
- etc. etc. etc.
RStudio and its team have contributed to many R packages.[13] These include:
- Tidyverse – R packages for data science, including ggplot2, dplyr, tidyr, and purrr
- Shiny – An interactive web technology
- RMarkdown – Insert R code into markdown documents
- knitr – Dynamic reports combining R, TeX, Markdown & HTML
- packrat – Package dependency tool
- devtools – Package development tool
RStudio Cheat Sheets: rstudio-ide.pdf
Topics covered in this introduction to R
- Basic concepts
- Basic data types in R
- Import and export data in R
- Functions in R
- Basic statistics in R
- Simple data visulization in R
- Install packages in R
- Save data in R session
Topic 1. Basic concepts
There are three concepts that we should be familiar with before working in R:
Assignment Operators in R
| Operator |
Description |
| <-, = |
Assignment |
Arithmetic Operators in R
| Operator |
Description |
| \+ |
Addition |
| \- |
Subtraction |
| \* |
Multiplication |
| / |
Division |
| ^ |
Exponent |
| %% |
Modulus |
| %/% |
Integer Division |
Relational Operators in R
| Operator |
Description |
| < |
Less than |
| > |
Greater than |
| <= |
Less than or equal to |
| >= |
Greater than or equal to |
| == |
Equal to |
| != |
Not equal to |
Logical Operators in R
| Operator |
Description |
| ! |
Logical NOT |
| & |
Element-wise logical AND |
| && |
Logical AND |
| | |
Element-wise logical OR |
| || |
Logical OR |
Functions are essential in all programming languages. A function takes zero or more parameters and return a result. The way to use a function in R is:
function.name(parameter1=value1, …)
A variable is a named storage. The name of a variable can have letters, numbers, dot and underscore. However, a valid variable name cannot start with a underscore or a number, or start with a dot that is followed by a number.
Topic 2. Basic data types in R
Simple variables: variables that have a numeric value, a character value (such as a string), or a logical value (True or False)
Examples of numeric values.
```{.r .colsel}
assign number 150 to variable a.
a <- 150
a
[1] 150
```{.r .colsel}
# assign a number in scientific format to variable b.
b <- 3e-2
b
[1] 0.03
Examples of character values.
```{.r .colsel}
assign a string “Professor” to variable title
title <- “Professor”
title
[1] “Professor”
```{.r .colsel}
# assign a string "Hello World" to variable hello
hello <- "Hello World"
hello
[1] "Hello World"
Examples of logical values.
```{.r .colsel}
assign logical value “TRUE” to variable is_female
is_female <- TRUE
is_female
[1] TRUE
```{.r .colsel}
# assign logical value "FALSE" to variable is_male
is_male <- FALSE
is_male
[1] FALSE
```{.r .colsel}
assign logical value to a variable by logical operation
age <- 20
is_adult <- age > 18
is_adult
[1] TRUE
To find out the type of variable.
```{.r .colsel}
class(is_female)
[1] "logical"
```{.r .colsel}
To check whether the variable is a specific type
is.numeric(hello)
[1] FALSE
```{.r .colsel}
is.numeric(a)
[1] TRUE
```{.r .colsel}
is.character(hello)
[1] TRUE
The rule to convert a logical variable to numeric: TRUE > 1, FALSE > 0
```{.r .colsel}
as.numeric(is_female)
[1] 1
```{.r .colsel}
as.numeric(is_male)
[1] 0
R does not know how to convert a numeric variable to a character variable.
```{.r .colsel}
b
[1] 0.03
```{.r .colsel}
as.character(b)
[1] “0.03”
# Vectors: a vector is a combination of multiple values(numeric, character or logical) in the same object. A vector is created using the function c() (for concatenate).
```{.r .colsel}
friend_ages <- c(21, 27, 26, 32)
friend_ages
[1] 21 27 26 32
```{.r .colsel}
friend_names <- c(“Mina”, “Ella”, “Anna”, “Cora”)
friend_names
[1] “Mina” “Ella” “Anna” “Cora”
One can give names to the elements of a vector.
```{.r .colsel}
# assign names to a vector by specifying them
names(friend_ages) <- c("Mina", "Ella", "Anna", "Carla")
friend_ages
Mina Ella Anna Carla
21 27 26 32
```{.r .colsel}
assign names to a vector using another vector
names(friend_ages) <- friend_names
friend_ages
Mina Ella Anna Cora
21 27 26 32
Or One may create a vector with named elements from scratch.
```{.r .colsel}
friend_ages <- c(Mina=21, Ella=27, Anna=26, Cora=32)
friend_ages
Mina Ella Anna Cora
21 27 26 32
To find out the length of a vector:
```{.r .colsel}
length(friend_ages)
[1] 4
To access elements of a vector: by index, or by name if it is a named vector.
```{.r .colsel}
friend_ages[2]
Ella
27
```{.r .colsel}
friend_ages[“Ella”]
Ella
27
```{.r .colsel}
friend_ages[c(1,3)]
Mina Anna
21 26
```{.r .colsel}
friend_ages[c(“Mina”, “Anna”)]
Mina Anna
21 26
```{.r .colsel}
# selecting elements of a vector by excluding some of them.
friend_ages[-3]
Mina Ella Cora
21 27 32
To select a subset of a vector can be done by logical vector.
```{.r .colsel}
my_friends <- c(“Mina”, “Ella”, “Anna”, “Cora”)
my_friends
[1] “Mina” “Ella” “Anna” “Cora”
```{.r .colsel}
has_child <- c("TRUE", "TRUE", "FALSE", "TRUE")
has_child
[1] "TRUE" "TRUE" "FALSE" "TRUE"
```{.r .colsel}
my_friends[has_child == “TRUE”]
[1] “Mina” “Ella” “Cora”
# NOTE: a vector can only hold elements of the same type.
# Matrices: A matrix is like an Excel sheet containing multiple rows and columns. It is used to combine vectors of the same type.
```{.r .colsel}
col1 <- c(1,3,8,9)
col2 <- c(2,18,27,10)
col3 <- c(8,37,267,19)
my_matrix <- cbind(col1, col2, col3)
my_matrix
col1 col2 col3
[1,] 1 2 8
[2,] 3 18 37
[3,] 8 27 267
[4,] 9 10 19
```{.r .colsel}
rownames(my_matrix) <- c(“row1”, “row2”, “row3”, “row4”)
my_matrix
col1 col2 col3
row1 1 2 8
row2 3 18 37
row3 8 27 267
row4 9 10 19
```{.r .colsel}
t(my_matrix)
row1 row2 row3 row4
col1 1 3 8 9
col2 2 18 27 10
col3 8 37 267 19
To find out the dimension of a matrix:
```{.r .colsel}
ncol(my_matrix)
[1] 3
```{.r .colsel}
nrow(my_matrix)
[1] 4
```{.r .colsel}
dim(my_matrix)
[1] 4 3
Accessing elements of a matrix is done in similar ways to accessing elements of a vector.
```{.r .colsel}
my_matrix[1,3]
[1] 8
```{.r .colsel}
my_matrix[“row1”, “col3”]
[1] 8
```{.r .colsel}
my_matrix[1,]
col1 col2 col3
1 2 8
```{.r .colsel}
my_matrix[,3]
row1 row2 row3 row4
8 37 267 19
```{.r .colsel}
my_matrix[col3 > 20,]
col1 col2 col3
row2 3 18 37
row3 8 27 267
Calculations with matrices.
```{.r .colsel}
my_matrix * 3
col1 col2 col3
row1 3 6 24
row2 9 54 111
row3 24 81 801
row4 27 30 57
```{.r .colsel}
log10(my_matrix)
col1 col2 col3
row1 0.0000000 0.301030 0.903090
row2 0.4771213 1.255273 1.568202
row3 0.9030900 1.431364 2.426511
row4 0.9542425 1.000000 1.278754
Total of each row.
```{.r .colsel}
rowSums(my_matrix)
row1 row2 row3 row4
11 58 302 38
Total of each column.
```{.r .colsel}
colSums(my_matrix)
col1 col2 col3
21 57 331
It is also possible to use the function apply() to apply any statistical functions to rows/columns of matrices. The advantage of using apply() is that it can take a function created by user.
The simplified format of apply() is as following:
apply(X, MARGIN, FUN)
X: data matrix
MARGIN: possible values are 1 (for rows) and 2 (for columns)
FUN: the function to apply on rows/columns
To calculate the mean of each row.
```{.r .colsel}
apply(my_matrix, 1, mean)
row1 row2 row3 row4
3.666667 19.333333 100.666667 12.666667
To calculate the median of each row
```{.r .colsel}
apply(my_matrix, 1, median)
row1 row2 row3 row4
2 18 27 10
Factors: a factor represents categorical or groups in data. The function factor() can be used to create a factor variable.
```{.r .colsel}
friend_groups <- factor(c(1,2,1,2))
friend_groups
[1] 1 2 1 2
Levels: 1 2
In R, categories are called factor levels. The function levels() can be used to access the factor levels.
```{.r .colsel}
levels(friend_groups)
[1] "1" "2"
Change the factor levels.
```{.r .colsel}
levels(friend_groups) <- c(“best_friend”, “not_best_friend”)
friend_groups
[1] best_friend not_best_friend best_friend not_best_friend
Levels: best_friend not_best_friend
Change the order of levels.
```{.r .colsel}
levels(friend_groups) <- c("not_best_friend", "best_friend")
friend_groups
[1] not_best_friend best_friend not_best_friend best_friend
Levels: not_best_friend best_friend
By default, the order of factor levels is taken in the order of numeric or alphabetic.
```{.r .colsel}
friend_groups <- factor(c(“not_best_friend”, “best_friend”, “not_best_friend”, “best_friend”))
friend_groups
[1] not_best_friend best_friend not_best_friend best_friend
Levels: best_friend not_best_friend
The factor levels can be specified when creating the factor, if the order does not follow the default rule.
```{.r .colsel}
friend_groups <- factor(c("not_best_friend", "best_friend", "not_best_friend", "best_friend"), levels=c("not_best_friend", "best_friend"))
friend_groups
[1] not_best_friend best_friend not_best_friend best_friend
Levels: not_best_friend best_friend
If you want to know the number of individuals at each levels, there are two functions.
```{.r .colsel}
summary(friend_groups)
not_best_friend best_friend
2 2
```{.r .colsel}
table(friend_groups)
friend_groups
not_best_friend best_friend
2 2
Data frames: a data frame is like a matrix but can have columns with different types (numeric, character, logical).
A data frame can be created using the function data.frame().
```{.r .colsel}
creating a data frame using previously defined vectors
friends <- data.frame(name=friend_names, age=friend_ages, child=has_child)
friends
name age child
Mina Mina 21 TRUE
Ella Ella 27 TRUE
Anna Anna 26 FALSE
Cora Cora 32 TRUE
To check whether a data is a data frame, use the function is.data.frame().
```{.r .colsel}
is.data.frame(friends)
[1] TRUE
```{.r .colsel}
is.data.frame(my_matrix)
[1] FALSE
One can convert a object to a data frame using the function as.data.frame().
```{.r .colsel}
class(my_matrix)
[1] "matrix"
```{.r .colsel}
my_data <- as.data.frame(my_matrix)
class(my_data)
[1] “data.frame”
A data frame can be transposed in the similar way as a matrix.
```{.r .colsel}
my_data
col1 col2 col3
row1 1 2 8
row2 3 18 37
row3 8 27 267
row4 9 10 19
```{.r .colsel}
t(my_data)
row1 row2 row3 row4
col1 1 3 8 9
col2 2 18 27 10
col3 8 37 267 19
To obtain a subset of a data frame can be done in similar ways as we have discussed: by index, by row/column names, or by logical values.
```{.r .colsel}
friends["Mina",]
name age child
Mina Mina 21 TRUE
```{.r .colsel}
The columns of a data frame can be referred to by the names of the columns
friends
name age child
Mina Mina 21 TRUE
Ella Ella 27 TRUE
Anna Anna 26 FALSE
Cora Cora 32 TRUE
```{.r .colsel}
friends$age
[1] 21 27 26 32
```{.r .colsel}
friends[friends$age > 26,]
name age child
Ella Ella 27 TRUE
Cora Cora 32 TRUE
```{.r .colsel}
friends[friends$child == "TRUE",]
name age child
Mina Mina 21 TRUE
Ella Ella 27 TRUE
Cora Cora 32 TRUE
Function subset() can also be used to get a subset of a data frame.
```{.r .colsel}
select friends that are older than 26
subset(friends, age > 26)
name age child
Ella Ella 27 TRUE
Cora Cora 32 TRUE
```{.r .colsel}
# select the information of the ages of friends
subset(friends, select=age)
age
Mina 21
Ella 27
Anna 26
Cora 32
A data frame can be extended.
```{.r .colsel}
friends$married <- c(“YES”, “YES”, “NO”, “YES”)
friends
name age child married
Mina Mina 21 TRUE YES
Ella Ella 27 TRUE YES
Anna Anna 26 FALSE NO
Cora Cora 32 TRUE YES
A data frame can also be extended using the functions cbind() and rbind().
```{.r .colsel}
# add a column that has the information on the salaries of friends
cbind(friends, salary=c(4000, 8000, 2000, 6000))
name age child married salary
Mina Mina 21 TRUE YES 4000
Ella Ella 27 TRUE YES 8000
Anna Anna 26 FALSE NO 2000
Cora Cora 32 TRUE YES 6000
Lists: a list is an ordered collection of objects, which can be any type of R objects (vectors, matrices, data frames).
A list can be created using the function list().
```{.r .colsel}
my_list <- list(mother=”Sophia”, father=”John”, sisters=c(“Anna”, “Emma”), sister_age=c(5, 10))
my_list
$mother
[1] “Sophia”
##
$father
[1] “John”
##
$sisters
[1] “Anna” “Emma”
##
$sister_age
[1] 5 10
```{.r .colsel}
# names of elements in the list
names(my_list)
[1] "mother" "father" "sisters" "sister_age"
```{.r .colsel}
number of elements in the list
length(my_list)
[1] 4
To access elements of a list can be done using its name or index.
```{.r .colsel}
my_list$mother
[1] "Sophia"
```{.r .colsel}
my_list[[“mother”]]
[1] “Sophia”
```{.r .colsel}
my_list[[1]]
[1] "Sophia"
```{.r .colsel}
my_list[[3]]
[1] “Anna” “Emma”
```{.r .colsel}
my_list[[3]][2]
[1] "Emma"
Topic 3. Import and export data in R
R base function read.table() is a general funciton that can be used to read a file in table format. The data will be imported as a data frame.
```{.r .colsel}
To read a local file. If you have downloaded the raw_counts.txt file to your local machine, you may use the following command to read it in, by providing the full path for the file location. The way to specify the full path is the same as taught in the command line session.
data <- read.table(file=”/Users/jli/Downloads/raw_counts.txt”, sep=”\t”, header=T, stringsAsFactors=F)
There is a very convenient way to read files from the internet.
data <- read.table(file=”https://raw.githubusercontent.com/ucdavis-bioinformatics-training/2017-August-Variant-Analysis-Workshop/master/friday/Intro2R/raw_counts.txt”, sep=”\t”, header=T, stringsAsFactors=F)
Take a look at the beginning part of the data frame.
```{.r .colsel}
head(data)
C61 C62 C63 C64 C91 C92 C93 C94 I561 I562 I563 I564 I591
AT1G01010 322 346 256 396 372 506 361 342 638 488 440 479 770
AT1G01020 149 87 162 144 189 169 147 108 163 141 119 147 182
AT1G01030 15 32 35 22 24 33 21 35 18 8 54 35 23
AT1G01040 687 469 568 651 885 978 794 862 799 769 725 715 811
AT1G01046 1 1 5 4 5 3 0 2 4 3 1 0 2
AT1G01050 1447 1032 1083 1204 1413 1484 1138 938 1247 1516 984 1044 1374
I592 I593 I594 I861 I862 I863 I864 I891 I892 I893 I894
AT1G01010 430 656 467 143 453 429 206 567 458 520 474
AT1G01020 156 153 177 43 144 114 50 161 195 157 144
AT1G01030 8 16 24 42 17 22 39 26 28 39 30
AT1G01040 567 831 694 345 575 605 404 735 651 725 591
AT1G01046 8 8 1 0 4 0 3 5 7 0 5
AT1G01050 1355 1437 1577 412 1338 1051 621 1434 1552 1248 1186
Depending on the format of the file, several variants of read.table() are available to make reading a file easier.
read.csv(): for reading “comma separated value” files (.csv).
read.csv2(): variant used in countries that use a comma “,” as decimal point and a semicolon “;” as field separators.
read.delim(): for reading “tab separated value” files (“.txt”). By default, point(“.”) is used as decimal point.
read.delim2(): for reading “tab separated value” files (“.txt”). By default, comma (“,”) is used as decimal point.
```{.r .colsel}
We are going to read a file over the internet by providing the url of the file.
data2 <- read.csv(file=”https://raw.githubusercontent.com/ucdavis-bioinformatics-training/2017-August-Variant-Analysis-Workshop/master/friday/Intro2R/raw_counts.csv”, stringsAsFactors=F)
To look at the file:
head(data2)
C61 C62 C63 C64 C91 C92 C93 C94 I561 I562 I563 I564 I591
AT1G01010 322 346 256 396 372 506 361 342 638 488 440 479 770
AT1G01020 149 87 162 144 189 169 147 108 163 141 119 147 182
AT1G01030 15 32 35 22 24 33 21 35 18 8 54 35 23
AT1G01040 687 469 568 651 885 978 794 862 799 769 725 715 811
AT1G01046 1 1 5 4 5 3 0 2 4 3 1 0 2
AT1G01050 1447 1032 1083 1204 1413 1484 1138 938 1247 1516 984 1044 1374
I592 I593 I594 I861 I862 I863 I864 I891 I892 I893 I894
AT1G01010 430 656 467 143 453 429 206 567 458 520 474
AT1G01020 156 153 177 43 144 114 50 161 195 157 144
AT1G01030 8 16 24 42 17 22 39 26 28 39 30
AT1G01040 567 831 694 345 575 605 404 735 651 725 591
AT1G01046 8 8 1 0 4 0 3 5 7 0 5
AT1G01050 1355 1437 1577 412 1338 1051 621 1434 1552 1248 1186
R base function write.table() can be used to export data to a file.
```{.r .colsel}
# To write to a file called "output.txt" in your current working directory.
write.table(data2[1:20,], file="output.txt", sep="\t", quote=F, row.names=T, col.names=T)
It is also possible to export data to a csv file.
write.csv()
write.csv2()
\newpage
Topic 4. Functions in R
Invoking a function by its name, followed by the parenthesis and zero or more arguments.
```{.r .colsel}
to find out the current working directory
getwd()
```{.r .colsel}
# to set a different working directory, use setwd
setwd("/Users/jli/Desktop")
# to list all variables in the environment
ls()
[1] "a" "actg" "actgm" "age"
[5] "b" "col1" "col2" "col3"
[9] "colFmt" "data" "data2" "fq"
[13] "fqm" "friend_ages" "friend_groups" "friend_names"
[17] "friends" "full" "g" "gc"
[21] "h" "has_child" "hello" "i"
[25] "i2" "ic" "id" "is"
[29] "is_adult" "is_female" "is_male" "j"
[33] "k" "l" "my_data" "my_friends"
[37] "my_list" "my_matrix" "new_is" "rl"
[41] "sn" "title" "x" "y"
```{.r .colsel}
to create a vector from 2 to 3, using increment of 0.1
seq(2, 3, by=0.1)
[1] 2.0 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9 3.0
```{.r .colsel}
# to create a vector with repeated elements
rep(1:3, times=3)
[1] 1 2 3 1 2 3 1 2 3
```{.r .colsel}
rep(1:3, each=3)
[1] 1 1 1 2 2 2 3 3 3
```{.r .colsel}
# to get help information on a function in R: ?function.name
?seq
?sort
?rep
```{.r .colsel}
str(data2)
‘data.frame’: 33602 obs. of 24 variables:
$ C61 : int 322 149 15 687 1 1447 2667 297 0 74 …
$ C62 : int 346 87 32 469 1 1032 2472 226 0 79 …
$ C63 : int 256 162 35 568 5 1083 2881 325 0 138 …
$ C64 : int 396 144 22 651 4 1204 2632 341 0 85 …
$ C91 : int 372 189 24 885 5 1413 5120 199 0 68 …
$ C92 : int 506 169 33 978 3 1484 6176 180 0 41 …
$ C93 : int 361 147 21 794 0 1138 7088 195 0 110 …
$ C94 : int 342 108 35 862 2 938 6810 107 0 81 …
$ I561: int 638 163 18 799 4 1247 2258 377 0 72 …
$ I562: int 488 141 8 769 3 1516 1808 534 0 76 …
$ I563: int 440 119 54 725 1 984 2279 300 0 184 …
$ I564: int 479 147 35 715 0 1044 2299 223 0 156 …
$ I591: int 770 182 23 811 2 1374 4755 298 0 96 …
$ I592: int 430 156 8 567 8 1355 3128 318 0 70 …
$ I593: int 656 153 16 831 8 1437 4419 397 0 77 …
$ I594: int 467 177 24 694 1 1577 3726 373 0 77 …
$ I861: int 143 43 42 345 0 412 1452 86 0 174 …
$ I862: int 453 144 17 575 4 1338 1516 266 0 113 …
$ I863: int 429 114 22 605 0 1051 1455 281 0 69 …
$ I864: int 206 50 39 404 3 621 1429 164 0 176 …
$ I891: int 567 161 26 735 5 1434 3867 230 0 69 …
$ I892: int 458 195 28 651 7 1552 4718 270 0 80 …
$ I893: int 520 157 39 725 0 1248 4580 220 0 81 …
$ I894: int 474 144 30 591 5 1186 3575 229 0 62 …
# Two special functions: lapply() and sapply()
lapply() is to apply a given function to every element of a vector and obtain a list as results.
The difference between lapply() and apply() is that lapply() can be applied on objects like dataframes, lists or vectors. Function apply() only works on an array of dimension 2 or a matrix.
# To check the syntax of using lapply():
```{.r .colsel}
#?lapply()
data <- as.data.frame(matrix(rnorm(49), ncol=7), stringsAsFactors=F)
dim(data)
[1] 7 7
```{.r .colsel}
lapply(1:dim(data)[1], function(x){sum(data[x,])})
[[1]]
[1] -0.245014
##
[[2]]
[1] -0.6737587
##
[[3]]
[1] 0.8720167
##
[[4]]
[1] -6.901058
##
[[5]]
[1] -1.824077
##
[[6]]
[1] 4.803424
##
[[7]]
[1] -2.255819
```{.r .colsel}
apply(data, MARGIN=1, sum)
[1] -0.2450140 -0.6737587 0.8720167 -6.9010579 -1.8240773 4.8034239
[7] -2.2558193
```{.r .colsel}
lapply(1:dim(data)[1], function(x){log10(sum(data[x,]))})
Warning in FUN(X[[i]], …): NaNs produced
Warning in FUN(X[[i]], …): NaNs produced
Warning in FUN(X[[i]], …): NaNs produced
Warning in FUN(X[[i]], …): NaNs produced
Warning in FUN(X[[i]], …): NaNs produced
[[1]]
[1] NaN
##
[[2]]
[1] NaN
##
[[3]]
[1] -0.0594752
##
[[4]]
[1] NaN
##
[[5]]
[1] NaN
##
[[6]]
[1] 0.6815509
##
[[7]]
[1] NaN
The function sapply() works like function lapply(), but tries to simplify the output to the most elementary data structure that is possible. As a matter of fact, sapply() is a "wrapper" function for lapply(). By default, it returns a vector.
```{.r .colsel}
# To check the syntax of using sapply():
#?sapply()
sapply(1:dim(data)[1], function(x){log10(sum(data[x,]))})
Warning in FUN(X[[i]], ...): NaNs produced
Warning in FUN(X[[i]], ...): NaNs produced
Warning in FUN(X[[i]], ...): NaNs produced
Warning in FUN(X[[i]], ...): NaNs produced
Warning in FUN(X[[i]], ...): NaNs produced
[1] NaN NaN -0.0594752 NaN NaN 0.6815509
[7] NaN
```{.r .colsel}
sapply(1:dim(data)[1], function(x){log10(sum(data[x,]))}, simplify=FALSE)
Warning in FUN(X[[i]], …): NaNs produced
Warning in FUN(X[[i]], …): NaNs produced
Warning in FUN(X[[i]], …): NaNs produced
Warning in FUN(X[[i]], …): NaNs produced
Warning in FUN(X[[i]], …): NaNs produced
[[1]]
[1] NaN
##
[[2]]
[1] NaN
##
[[3]]
[1] -0.0594752
##
[[4]]
[1] NaN
##
[[5]]
[1] NaN
##
[[6]]
[1] 0.6815509
##
[[7]]
[1] NaN
---
Topic 5. Basic statistics in R
====================================================
| Description |
R_function |
| Mean |
mean() |
| Standard deviation |
sd() |
| Variance |
var() |
| Minimum |
min() |
| Maximum |
max() |
| Median |
median() |
| Range of values: minimum and maximum |
range() |
| Sample quantiles |
quantile() |
| Generic function |
summary() |
| Interquartile range |
IQR() |
Calculate the mean expression for each sample.
```{.r .colsel}
apply(data, 2, mean)
V1 V2 V3 V4 V5
-0.4435852071 -1.1030767212 0.1331481105 0.2694271292 0.0002037773
V6 V7
0.3564623932 -0.1017632836
Calculate the range of expression for each sample.
```{.r .colsel}
apply(data, 2, range)
V1 V2 V3 V4 V5 V6
[1,] -1.4631972 -3.1317446 -1.246871 -0.8968486 -1.706961 -0.7695101
[2,] 0.4937927 0.2814704 1.492761 1.1531277 1.814351 3.0289903
V7
[1,] -1.292674
[2,] 0.770549
Calculate the quantiles of each samples.
```{.r .colsel}
apply(data, 2, quantile)
V1 V2 V3 V4 V5 V6
0% -1.46319721 -3.1317446 -1.2468712 -0.8968486 -1.7069609 -0.7695101
25% -0.85268688 -1.7268442 -0.4971252 0.1393153 -0.5510717 -0.5953214
50% -0.55538224 -1.1406425 -0.3488181 0.3216274 0.2001235 -0.5526572
75% 0.06253203 -0.1384660 1.0146077 0.5147264 0.3980279 0.9895282
100% 0.49379272 0.2814704 1.4927610 1.1531277 1.8143515 3.0289903
V7
0% -1.2926743
25% -0.4275890
50% -0.1624996
75% 0.4137300
100% 0.7705490
Topic 6. Simple data visulization in R
Scatter plot and line plot can be produced using the function plot().
```{.r .colsel}
x <- c(1:50)
y <- 1 + sqrt(x)/2
plot(x,y)
![](Intro2R_files/figure-html/unnamed-chunk-69-1.png)
```{.r .colsel}
plot(x,y, type="l")
```{.r .colsel}
plot both the points and lines
first plot points
plot(x,y)
lines(x,y, type=”l”)
![](Intro2R_files/figure-html/unnamed-chunk-69-3.png)
```{.r .colsel}
lines() can only be used to add information to a graph, while it cannot produce a graph on its own.
boxplot() can be used to summarize data.
```{.r .colsel}
boxplot(data, xlab=”Sample ID”, ylab=”Raw Counts”)
![](Intro2R_files/figure-html/unnamed-chunk-70-1.png)
```{.r .colsel}
x <- rnorm(1000)
boxplot(x)
hist() can be used to create histograms of data.
```{.r .colsel}
hist(x)
![](Intro2R_files/figure-html/unnamed-chunk-72-1.png)
```{.r .colsel}
# use user defined break points
hist(x, breaks=seq(range(x)[1]-1, range(x)[2]+1, by=0.5))
```{.r .colsel}
clear plotting device/area
dev.off()
null device
1
---
Topic 7. Install packages in R
====================================================
Starting from Bioconductor version 3.8, the installation of packages is recommended to use BiocManager.
```{.r .colsel}
if (!requireNamespace("BiocManager"))
install.packages("BiocManager")
install core packages
BiocManager::install()
install specific packages
BiocManager::install(c("ggplot2", "ShortRead"))
-
Bioconductor has a repository and release schedule that differ from R (Bioconductor has a ‘devel’ branch to which new packages and updates are introduced, and a stable ‘release’ branch emitted once every 6 months to which bug fixes but not new features are introduced). This mismatch causes that the version detected by install.packages() is sometimes not the most recent ‘release’.
-
A consequence of the distince ‘devel’ branch is that install.packages() sometimes points only to the ‘release’ repository, while users might want to have access to the leading-edge features in the develop version.
-
An indirect consequence of Bioconductor’s structured release is that packages generally have more extensive dependences with one another.
It is always recommended to update to the most current version of R and Bioconductor. If it is not possible and R < 3.5.0, please use the legacy approach to install Bioconductor packages
```{.r .colsel}
source(“http://bioconductor.org/biocLite.R”)
install core packages
biocLite()
install specific packages
biocLite(“RCircos”)
biocLite(c(“IdeoViz”, “devtools”))
The R function install.packages() can be used to install packages that are not part of Bioconductor.
```{.r .colsel}
install.packages("ggplot2", repos="http://cran.us.r-project.org")
Install from source of github.
```{.r .colsel}
library(devtools)
install_github(“stephenturner/qqman”)
---
Topic 8. Save data in R session
====================================================
To save history in R session
```{.r .colsel}
savehistory(file="March27.history")
#loadhistory(file="March27.history")
To save objects in R session
```{.r .colsel}
save(list=c(“x”, “data”), file=”March27.RData”)
#load(“March27.RData”)


MUTANT SITUATIONS
With his debut album, outspoken rapper Le1f aims to transcend his viral moment
By Devon Maloney | Photography by Alex Welsh
The one thing you never hear about Khalif Diouf is how much he laughs.
In general, the native New York rapper — better known as Le1f — is portrayed as a soft-spoken, yet deadly serious provocateur wholly dedicated to his bawdy, politically charged party raps. He helps that image along, of course: confrontational onstage, always strictly composed and mean-mugging like a couture model in photoshoots, and ready to unleash a social media beatdown on anyone unwise enough to call him transphobic or make bigoted comments about his career.
But in person, that all melts away with the arrival of his big, endearing exclamation point of a chortle, one that bursts loudly and often over whatever space he happens to inhabit — for example, a beige booth in a Midtown Manhattan diner, talking to a reporter about X-Men.
Artikel 5
"I was just into mutant… situations," he says of his nerdy childhood, laughing over a plate of plain French toast. (They were out of cinnamon-raisin bread.) He’s ordered a pitcher of water, too, worried he’s getting sick before his CMJ show at Williamsburg’s Cameo Gallery later this week. "I always liked Iceman, but he just came out of the closet. He said he didn’t want to before because he didn’t want to deal with the double-discrimination.  Get over it.’"


This module supports you in writing PMD's ruleset xml files.
You can define in your custom rulesets your own pmd rules. Once you have defined your custom rules, and rulesets pass them on to PMD.
The PMD netbeans integration module allows you specify rulesets used by PMD in the netbeans integration options panel.
You can read more about PMD, and PMD's ruleset definition:
The module itself does not require any special installation steps, beside the usual Netbeans module installation.
If you want to invoke the PMD designer tool from within this module, you need to specify the PMD installation directory in the module's options dialog.
This modules supports you in writing PMD ruleset xml files, by providing:
A ruleset template is available via New File|PMD|PMD SimpleRuleset. You can use this template to start writing you own PMD rulesets.
Moreover you can store your own PMD ruleset templates in PMD template folder.
You can browse the rulesets delivered by PMD-3.9, learning the already provided rules, and rulesets.
In the explorer tab
Runtime the node DTD and XML Schema Catalogs|PMD Ruleset Catalog defines
the ruleset schema definition (http://pmd.sf.net/ruleset/1.0.0
).
By defining the ruleset schema, you can validate your ruleset xml files via the context menu entry Validate XML.
In Netbeans version 5.5.1 and above, xml code completion might work.
The the main menu the entry Tools|PMD Designer launches PMD's ruleset designer. The designer helps you in writing proper xpath definitions.
Note: you have to specify the PMD's home directory before launching the designer, see the section below.
You can find the option dialog by clicking the menu bar Tools|Options|Miscellaneous|PMD Ruleset.
The options dialog allows you to specify the home directory of the downloaded, and extracted PMD binary distribution.
The PMD's ruleset designer is launched by an internal ant script, defining the designer classpath
as ${pmd.home}/lib/*.jar
.


After coming here from galaxies unknown, Adrian Guerra has decided to devote his life to fish tacos. And science! This is why today he is showing you this web app, a fleeting moment in his neverending quest towards the meaning of truth and the key to light and time travel. He is getting closer each day.


WITNESS LIST Financial Institutions Committee March 17, 1997-2:00P HB 1870 For: Blair, Timothy (Himself) Temple, Larry (TBA/Trust Fin Svcs Div) On: Ghiglieri, Catherine (Dept of Banking) Registering, but not testifying: For: Hughes, Dianne (TBA/Trust Fin Svcs Div) McDonald, Carol (Indep Colleges & Univ) Rodgers, Kelly (TBA) On: James, Randall (Dept of Banking) HB 1971 For: Bresnen, Kenneth (Himself) Kelley, Sam (Tx Auto Dealers Assoc) Ronay, James (Himself) Stinson, Bill (Himself) Against: Boudreau, Gerald (Himself/Startup Computr) Broussard, William (Himself) Peten, Jeannette (Small Businesses) On: Ghiglieri, Catherine (Dept of Banking) Pettijohn, Leslie (Ofc Consumer Credit Com) Registering, but not testifying: For: Howden, Robert (Natl Fed of Indep Busn) Neeley, Karen (IBAT) Perkins, Arthur Val (Tx Busn Law Foundatn) Pinkus, David (Sm Busn United of Texas) Rodgers, Kelly (TBA) Sheehan, J Scott (Himself) HB 2105 For: Woolley, Rep. Beverly (Herself) On: Joyner, Guy (Ofc of the Sec of State) HB 2274 For: Shields, Rep. John (Himself) Registering, but not testifying: For: Hickson, Elizabeth (Herself) Payne, Tyson (Tx Assoc Life Underwrit) Tooley, Kenneth (Tx Assoc Life Underwrit) HB 2351 For: Shawn, Jim (Himself/Srvc Insr Group) On: Schnieder, Rob (Consumers Union) Registering, but not testifying: For: Erben, Randy (Service Insurance Group) Rodgers, Kelly (TBA) HB 2436 For: Clayton, Bill (Tx Assoc Check Cashers) Keel, Rep. Terry (Himself) Myers, Joseph (US Dept. of Treasury) On: Boatwright, David (Ofc of the Atty Genl) Ghiglieri, Catherine (Dept of Banking) Johnson, Brian (Ofc of the Atty Genl) Registering, but not testifying: On: Johnson, D'Ann (Dept of Banking)


Crazy Arcade Medals
I don't know why I made this.
Oops!
Failed to load data.
Click here to retry
or
let me know about the issue.
Icon
Level
Color
Name
Line Color
Line Name
Required Exp.
Total Exp.


JSpinner
- A Simple Sequence ContainerThis document describes the new Swing component, JSpinner.
One of the most commonly requested new Swing components is a spinner - a single line input field that lets the user select an number or an object value from an ordered set. Spinners typically provide a pair of tiny arrow buttons for stepping through the possible values, the up/down arrow keys also cycle through the values. The user may also be allowed to type a (legal) value directly into the spinner. Although combo boxes provide similar functionality, spinners are sometimes preferred because they don't require a drop down list that can obscure important data.
The bugtraq report that corresponds to this change is: 4290529.
Spinners are common in modern GUIs. Here are some examples from some popular look and feels and from OpenWindows:
| Windows | CDE/Motif | JLF | Mac Aqua | OpenWindows |
All of the spinners deliver very simple behavior: clicking on the arrow buttons changes the fields value and, when the spinner has the focus, the keyboard up and down arrow keys do the same. In some applications the spinners up or down arrow button is disabled when the upper or lower limit of the spinner has been reached, in other cases the spinner just resets its value to the opposite extreme.
JSpinner
, SpinnerModel
,
SpinnerListModel
The JSpinner
class is a simple Swing container that manages three children: two
arrow buttons and a single component, called the editor that
displays the spinner's value. The value displayed by the spinner is
encapsulated by model of a sequence of objects called a SpinnerModel
.
public interface SpinnerModel { Object getValue(); void setValue(Object); Object getNextValue(); Object getPreviousValue(); void addChangeListener(ChangeListener x); void removeChangeListener(ChangeListener x);}
The SpinnerModel
interface is similar to
ListModel
- they both represent a sequence a values -
however there are some important differences:
size
method.ListModels
sequence, which are read-only. This
difference reflects the different roles of JList
and
JSpinner
. The former was designed to simplify
selecting one or more items from a list and the latter for
entering a single value directly.The relationship between the JSpinner
and its model
is simple. The editor component monitors the model with a
ChangeListener
and always displays the object returned
by SpinnerModel.getValue()
. The up and down arrow
buttons update the value by calling
setValue(getNextValue())
or
setValue(getPreviousValue())
respectively. The
getNextValue
and getPreviousValue
methods
return null
when the end or the beginning of the
sequence has been reached, so the arrow button actions have to
check for null
before updating the models value. If
the editor is a writable field of some kind, it's responsible for
honoring the constraints defined by the model or handling the
IllegalArgumentException
thrown by
setValue
for invalid values.
The SpinnerListModel
provides support for two common mutable sequence types:
java.util.List
, and an array of objects. For example
to create a JSpinner
that lets the user choose a day
of the week in the default locale one could write:
String[] days = new DateFormatSymbols().getWeekdays(); SpinnerModel model = new SpinnerListModel(days); JSpinner spinner = new JSpinner(model);
In addition to initializing the model
property of
the spinner, these constructors create an editor component that
displays the SpinnerModel
's value
and can
be used to change it. The protected
JSpinner.createEditor
method is used for this and, by
default, it creates a JFormattedTextField
that has
been configured to display the model.
To find or initialize a spinners current value one can either
use the models value
property or use the convenience
JSpinner
value
property which just
delegates to the model. For example, using the spinner configured
in the example above, the following two statements are
equivalent:
String selectedDay = spinner.getModel().getValue().toString(); String selectedDay = spinner.getValue().toString();
Setting the spinner's value is similar. Attempts to set the
SpinnerModel
value to an object that the model doesn't
support cause an IllegalArgumentException
to be
thrown.
Dates and numbers are two of the most common applications for a
spinner component. To simplify spinning these types, two additional
SpinnerModel
implementation classes are provided:
SpinnerDateModel
and
SpinnerNumberModel
.
SpinnerDateModel
One of the most common uses of a spinner is to compactly present
an editable date. Here's a simple example of creating a
JSpinner
that allows the user to enter a (fully
localized) date:
SpinnerDateModel model = new SpinnerDateModel(); JSpinner spinner = new JSpinner(model); Date value = model.getDate();
In this example, the JSpinner
constructor has
created a JFormattedTextField
editor that's configured
for editing dates and it has added a ChangeListener
to
the SpinnerDateModel
to keep the editor
and the model in sync.
Here's the SpinnerDateModel
API. We've added three new read/write properties:
start
, end
, and stepSize
and
a read-only date
property that returns the models
value cast to a Date
.
public class SpinnerDateModel extends AbstractSpinnerModel { public SpinnerDateModel(Date value, Comparable start, Comparable end, int stepSize) public SpinnerDateModel() public void setStart(Comparable start) public Comparable getStart() public void setEnd(Comparable end) public Comparable getEnd() public Object getNextValue() public Object getPreviousValue() public Date getDate() public Object getValue() public void setValue(Object value)}
The startDate
and endDate
properties
can be null
to indicate that there is no lower or
upper limit. The no-arguments SpinnerDateModel
constructor initializes both the start and end date to
null
, the initial value of the model is the current
date.
The value of the stepSize
property must be one of
the java.util.Calendar
constants that specify a field
within a Calendar
. The getNextValue
and
getPreviousValue
methods change the date forward or
backwards by this amount. For example, if stepSize
is
Calendar.DAY_OF_WEEK
, then nextValue
produces a Date
that's 24 hours after the current
value
, and previousValue
produces a
Date
that's 24 hours earlier.
The legal values for stepSize
are:
Calendar.ERA
Calendar.YEAR
Calendar.MONTH
Calendar.WEEK_OF_YEAR
Calendar.WEEK_OF_MONTH
Calendar.DAY_OF_MONTH
Calendar.DAY_OF_YEAR
Calendar.DAY_OF_WEEK
Calendar.DAY_OF_WEEK_IN_MONTH
Calendar.AM_PM
Calendar.HOUR
Calendar.HOUR_OF_DAY
Calendar.MINUTE
Calendar.SECOND
Calendar.MILLISECOND
The default SpinnerDateModel
editor
adjusts the stepSize
property based on the text cursor
position. For example if the cursor moves into the editor's month
subfield then the incrementSize
would be changed to
Calendar.DAY_OF_MONTH
.
Spinners are often used to present editable integers and real
numbers that represent everything from temperature to stock prices.
The SpinnerNumberModel
provides basic support for all of the basic Java
Number
types, from Byte
to
Double
.
To create a spinner that allows the user to pick a real multiple of 1/8 between 0.0 and 1000.0, with an initial value of 500.0, one could write:
SpinnerNumberModel model = new SpinnerNumberModel(500.0, 0.0, 1000.0, 0.625); JSpinner spinner = new JSpinner(model); double value = model.getNumber().doubleValue();
In this example, the JSpinner
constructor has
created a JFormattedTextField
editor that's configured
for editing real numbers and it has added a
ChangeListener
to the SpinnerNumberModel
to keep the editor
and the model in sync.
Here's a summary of the SpinnerNumberModel
API.
We've added three new read/write properties: minimum
,
maximum
, and stepSize
and a read-only
number
property that returns the models
value
cast to a Number
.
public class SpinnerNumberModel extends AbstractSpinnerModel { public SpinnerNumberModel(Number value, Comparable minimum, Comparable maximum, Number stepSize) public SpinnerNumberModel(int value, int minimum, int maximum, int stepSize) public SpinnerNumberModel(double value, double minimum, double maximum, double stepSize) public SpinnerNumberModel() public void setMinimum(Comparable minimum) public Comparable getMinimum() public void setMaximum(Comparable maximum) public Comparable getMaximum() public void setStepSize(Number stepSize) public Number getStepSize() public Object getNextValue() public Object getPreviousValue() public Number getNumber() public Object getValue() public void setValue(Object value)}
As with the SpinnerDateModel
, the
minimum
and maximum
properties can be
null
to indicate that there is no lower or upper
limit. The stepSize
property just specifies how much
to add or subtract from the value
to compute the
nextValue
or the previousValue
.
Support for spinners added six classes and one interface
(SpinnerModel
) to the javax.swing
package:
Additionally, SpinnerUI
has been added to the
javax.swing.plaf
package and
BasicSpinnerUI
to the
javax.swing.plaf.basic
package:


9:41
Vancouver to Tokyo
Tokyo Disneyland is a theme park based on the films produced by Walt Disney. It was opened in 1983 as the first Disney theme park outside of the United States. Modeled after Disneyland in California and the Magic Kingdom in Florida, Tokyo Disneyland is made up of seven exciting major theme parks.
A good place to spend your days with friends and families for sure!
Tokyo Disneyland 83% of users go there
Plan
Home
Me
Search
Event Skipped


There are too many things to do in Rome so here is our ranked list.
Here is some more detailed content that we can play with and apply different tags to.
Be sure to do this thing.
Arrive early at the sistine chapel and bribe the attendant to let you in early before the crowds. Trust me this is totally a thing.


- LARGEDELIM - Static variable in interface mlp.PomParserConstants
-
RegularExpression Id.
- LatexMacro - Class in mlp
-
This class models LaTeX macros, that is, new user-defined LateX commands
that are specified using one of the following
LaTeX commands: \newcommand, \renewcommand, and \providecommand.
- LatexMacro(String, String) - Constructor for class mlp.LatexMacro
-
Constructor; the constructed macro takes no arguments.
- LatexMacro(String, int, String) - Constructor for class mlp.LatexMacro
-
Constructor.
- LatexMacro(String, int, String, String) - Constructor for class mlp.LatexMacro
-
Constructor.
- LatexUnicode - Class in mlp
-
A utility class for reading a file that has Unicodes and
corresponding Latex commands/macros along with a brief description for
each code, in a "raw" form, and returning a clean version of that.
- LatexUnicode() - Constructor for class mlp.LatexUnicode
-
- LBRACE - Static variable in interface mlp.PomParserConstants
-
RegularExpression Id.
- LBRACKET - Static variable in interface mlp.PomParserConstants
-
RegularExpression Id.
- LEFTDELIM - Static variable in interface mlp.PomParserConstants
-
RegularExpression Id.
- LESS_THEN - Static variable in interface mlp.PomParserConstants
-
RegularExpression Id.
- LETTER - Static variable in interface mlp.PomParserConstants
-
RegularExpression Id.
- LexicalError(boolean, int, int, int, String, char) - Static method in error mlp.TokenMgrError
-
Returns a detailed message for the Error when it is thrown by the
token manager to indicate a lexical error.
- Lexicon - Class in mlp
-
Models a lexicon, where each entry is a (key,value) pair.
- Lexicon() - Constructor for class mlp.Lexicon
-
Constructs an unnamed Lexicon object
- Lexicon(String) - Constructor for class mlp.Lexicon
-
Constructs a named Lexicon object
- Lexicon(String, Map<String, List<FeatureSet>>) - Constructor for class mlp.Lexicon
-
Constructs a named Lexicon object, populated by the specified
map of (lexical key, feature-sets) pairs.
- Lexicon(Map<String, List<FeatureSet>>) - Constructor for class mlp.Lexicon
-
Constructs an unnamed Lexicon object, populated by the specified
map of (lexical key, feature-sets) pairs.
- LexiconFactory - Class in mlp
-
A factory class with static methods to create Lexicon objects from input
files, write Lexicons into files, merge Lexicons, change the names
of features and the names of feature-sets, and provides
some other Lexicon related methods.
- LexiconFactory() - Constructor for class mlp.LexiconFactory
-
- LexiconUtility - Class in mlp
-
A utility class that has static methods for manipulating lexicons.
- LexiconUtility() - Constructor for class mlp.LexiconUtility
-
- lexStateNames - Static variable in class mlp.PomParserTokenManager
-
Lexer state names.
- LINEBREAK - Static variable in interface mlp.PomParserConstants
-
RegularExpression Id.
- linesToFile(Iterable<? extends CharSequence>, String) - Static method in class mlp.MlpUtility
-
Writes the specified lines into the specified file.
- loadFeatureSets(Lexicon) - Method in class mlp.MathTerm
-
Loads a list of alternative feature sets for the underlying math term
from the specified Lexicon lex.
- LOWERCASE_LETTER - Static variable in interface mlp.PomParserConstants
-
RegularExpression Id.
- LPAREN - Static variable in interface mlp.PomParserConstants
-
RegularExpression Id.


{% extends "soc/student/public.html" %} {% comment %} Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. {% endcomment %} {% block header_title %} {{ page_name }} {{ entity.link_id }} for {{ entity.scope_path }} {% endblock %} {% block manage %}


FAQ
How can I minimize CPU and battery usage?
In general, try to reduce the amount of audio data being pushed through
the system and the amount of resampling that must be done.
All sounds (apart from compressed streams on Android) are resampled
by the Cricket Audio mixer to the output sample rate of 48 kHz. The
mixer has predefined resamplers at some standard sample rates:
- 8 kHz
- 11.025 kHz
- 12 kHz
- 16 kHz
- 22.050 kHz
- 24 kHz
- 32 kHz
- 44.1 kHz
Any sounds at these predefined sample rates can be mixed together and
then resampled to 48 kHz, rather than being resampled
individually. So if you will be playing many sounds at once, it
is more efficient if they are all at one of these sample rates.
Applying pitch shift (or, equivalently, a speed factor) to a sound requires an additional resampling pass for that sound.
Using mono instead of stereo, and lower sample rate source data, will
decrease the amount of data that needs to be processed; this will lower
your CPU usage, as well as decrease the size of your bank
files, but there may be a loss of audio quality.
Also, your choice of audio encoding is important. PCM16 and PCM8
are the most efficient; ADPCM is less efficient; and stream formats
such as MP3, MP4, or Ogg Vorbis are the least efficient. (However,
depending on your target platform, there may be hardware support for
decoding some of these stream formats; see this FAQ entry.)
Is there support for hardware acceleration of decoding?
This depends on the particular audio encoding, and your platform.
On iOS, at time of writing, there is hardware support for decoding the following formats:
- AAC (MPEG-4 Advanced Audio Coding)
- ALAC (Apple Lossless)
- HE-AAC (MPEG-4 High-Efficiency AAC)
- MP3 (MPEG-1 audio layer 3)
Hardware support is limited to a single stream; additional streams will use software decoding, if available.
For more information, see the iOS Multimedia Programming Guide.
On Android, there are no guarantees about hardware support; it is entirely up to the device manufacturer.
Why can't I load my large bank file on Android? I get an error message about "UNCOMPRESS_DATA_MAX".
Android versions prior to 2.3 cannot read compressed assets with an
uncompressed size greater than 1 MB. To get around this
restriction, you can try to break up your bank file into multiple
smaller banks with uncompressed size less than 1 MB, or you can disable
compression for your bank.
To disable compression, if you are building your .apk manually using the aapt tool, you can use the -0 flag (e.g. "-0 ckb" to disable compression for bank files with the .ckb
file extension). However, if you are building your .apk
automatically from Eclipse, there is currently no way to specify this
flag; a workaround is to give your bank file a file extension for
which aapt already disables compression, such as .jpg or .wma.
See this link
for a more detailed description of this problem and its
workarounds. Note that Android versions 2.3 and later do not have
this restriction.
Why can't I set pitch on MP3 streams on Android?
Whenever possible, we try to use the Android platform (using the OpenSL
ES API) for decoding of audio, so we can take advantage of any hardware
acceleration present on the device. While the Android platform
provides a way to play compressed streams (e.g. MP3, etc), it does not provide a way to decompress them into
memory. This means we cannot decompress the data using the
Android platform, and then perform
our own processing with them, so we are limited to using the features
provided by Android itself for compressed streams.
Cricket Audio can decode Ogg Vorbis audio files using a software decoder on all platforms, if CkConfig.enableOggVorbis is set to true (which is the default), so pitch adjustment and other processing can be done with those files.
Which iOS and Android versions do you support?
On iOS, Cricket Audio is tested for versions 5.0 and later.
On Android, Cricket Audio is tested for versions 2.2 and later.
On Android, note that some features are unavailable depending on the Android version of the device:
- In versions prior to 2.3, only .cks and .ogg stream sounds are supported, and network sounds are not supported.
How do I determine the URL for an item in the iTunes library for use with CkSound::newAssetStreamSound()?
Here's some sample code that will create a sound to play an item with a particular title in the iTunes library:
#import <MediaPlayer/MediaPlayer.h>
MPMediaQuery *query = [[MPMediaQuery alloc] init];
[query addFilterPredicate:[MPMediaPropertyPredicate
predicateWithValue:@"Some Song Title"
forProperty:MPMediaItemPropertyTitle]];
CkSound* sound = NULL;
if ([query.items count] > 0)
{
MPMediaItem* item = [query.items objectAtIndex:0];
NSURL* assetUrl = [item valueForProperty:MPMediaItemPropertyAssetURL];
// assetUrl will be nil if track is protected with DRM
if (assetUrl)
{
sound = CkSound::newAssetStreamSound([assetUrl.absoluteString UTF8String]);
}
}
For full details, see the iPod Library Access Programming Guide in the iOS Developer Library.
I'm writing a music app for iOS, and am supporting remote control
events. How do I make the play icon in the status bar disappear
when I'm not playing music?
After calling CkInit(), call CkSuspend().
This stops audio processing entirely, causing iOS to hide the play icon
in the status bar. When you start to play music, call CkResume() to show the icon; when the music stops, call CkSuspend() again to hide it.
Why are my banks/streams loading on the iPhone/iPad Simulator, but not on the device?
File paths are case-sensitive on iOS devices, but not on the simulator; make sure your file paths have the correct case.
How can I stream audio that is in a proprietary or unsupported data format?
First, create a subclass of CkCustomStream that decodes your data into 16-bit signed integer PCM audio data; then call CkSound::newCustomStream(), passing in an instance of your subclass.


“Kalyāṇamittatā muninā,
lokaṁ ādissa vaṇṇitā;
Kalyāṇamitte bhajamāno,
api bālo paṇḍito assa.
“Pointing out how the world works,
the sages have praised good friendship.
Associating with good friends,
even a fool becomes astute.
Bhajitabbā sappurisā,
Paññā tathā vaḍḍhati bhajantānaṁ;
Bhajamāno sappurise,
Sabbehipi dukkhehi pamucceyya.
Associate with good people,
for that is how wisdom grows.
Should you associate with good people,
you would be freed from all suffering.
Dukkhañca vijāneyya,
Dukkhassa ca samudayaṁ nirodhaṁ;
Aṭṭhaṅgikañca maggaṁ,
Cattāripi ariyasaccāni”.
And you would understand suffering,
its origin and cessation,
the eightfold path,
and so the four noble truths.”
“Dukkho itthibhāvo,
Akkhāto purisadammasārathinā;
Sapattikampi hi dukkhaṁ,
Appekaccā sakiṁ vijātāyo.
“‘A woman’s life is painful,’
explained the Buddha, guide for those who wish to train,
‘and for a co-wife it’s especially so.
After giving birth just once,
Galake api kantanti,
Sukhumāliniyo visāni khādanti;
Janamārakamajjhagatā,
Ubhopi byasanāni anubhonti”.
some women even cut their own throat,
while refined ladies take poison.

“I was on the road and about to give birth.,
when I saw my husband dead.
I gave birth there on the road
before I’d reached my own house.
Dve puttā kālakatā,
Patī ca panthe mato kapaṇikāya;
Mātā pitā ca bhātā,
Ḍayhanti ca ekacitakāyaṁ”.
My two children have died,
and on the road my husband lies dead—oh woe is me!
Mother, father, and brother
all burning up on the same pyre.”
“Khīṇakulīne kapaṇe,
Anubhūtaṁ te dukhaṁ aparimāṇaṁ;
Assū ca te pavattaṁ,
Bahūni ca jātisahassāni.
“Oh woe is you whose family is lost,
your suffering has no measure;
you have been shedding tears
for many thousands of lives.”
Vasitā susānamajjhe,
Athopi khāditāni puttamaṁsāni;
Hatakulikā sabbagarahitā,
Matapatikā amatamadhigacchiṁ.
“While staying in the charnel ground,
I saw my son’s flesh being eaten.

Bhāvito me maggo,
Ariyo aṭṭhaṅgiko amatagāmī;
Nibbānaṁ sacchikataṁ,
Dhammādāsaṁ avekkhiṁhaṁ.
I’ve developed the noble eightfold path
leading to the deathless.
I’ve realized quenching,
as seen in the mirror of the Dhamma.
Ahamamhi kantasallā,
Ohitabhārā katañhi karaṇīyaṁ;
Kisā gotamī therī,
Vimuttacittā imaṁ bhaṇī”ti.
I’ve plucked out the dart,
laid down the burden, and done what needed to be done.”
The senior nun Kisāgotamī,
her mind released, said this.
…
Kisā gotamī therī ….


This example shows you how to build a mobile application that connects to your LightBlue Bean and, when connected, allows you to configure the LED as well as read the ambient temperature.
You can browse the source code for this example at the Evothings GitHub repository
The file index.html contains the HTML markup of the app and the buisness logic is placed in the app.js
The Arduino sketch can be found here.
This example runs in Evothings Viewer on Android or iOS.
An iOS device or an Android device with support for Bluetooth 4.0 (which includes BLE) is required. For Android version 4.3 or later is needed.
You need a LightBlue Bean device.
As for now you need a computer running Mac OS X in order to upload a sketch. (Punch Through Design are currently working on Windows 8 support).
Follow these steps to get started with this example:
Read more in the blog post that explains the LightBlue Bean application example in detail.


Rock n roll
Rock and roll (also known as rock ’n’ roll) is a form of music that evolved in the United States in the late 1940s and early 1950s. Its roots lay mainly in rhythm and blues, country, folk, gospel, and jazz. The style quickly spread to the rest of the world and developed further, leading ultimately to modern rock music. The term "rock and roll" now covers at least two different meanings, both in common usage. The American Heritage Dictionary and the Merriam-Webster Dictionary both define rock and roll as synonymous with rock music. Read more on Last.fm.
Elvis Presley
Elvis Aaron Presley (Tupelo, Mississippi, January 8, 1935 - Memphis, Tennessee, August 16, 1977), was an American singer, song producer and actor. A cultural icon, he is widely known by the single name Elvis. Elvis Presley began his music career at Sun Records in the spring of 1954 when Sam Philips recorded Elvis performing several of Elvis' favorite songs with Scotty Moore (guitar) and Bill Black (bass). One of these covers was a country and western song, "Blue Moon of Kentucky". Read more on Last.fm
- Jailhouse Rock
- Johnny B. Goode


The following sections describe the manual configuration on the server-side Steelhead appliance for enabling latency optimizations in a secure environment. Riverbed recommends using the automatic configuration as described Configuring Domain Authentication Automatically, as it performs these steps automatically. Use this operation instead of the automatic configuration to set up delegate users in Active Directory. After running this operation, you can enable secure protocol optimization for CIFS SMB1, SMB2, SMB3, and encrypted MAPI for all clients and servers.For details about configuring domain authentication manually, see the white paper Optimizing in a Secure Windows Environment.Follow the procedures in this section after joining a Windows domain and enabling the SMB Signing, HTTP, or MAPI optimization features. For details, see Configuring SMB Signing, Configuring MAPI Optimization, or Configuring HTTP Optimization.Delegation mode in requires that you manually grant the user access to delegate. A delegate user is required in each of the domains where a server is going to be optimized.In Windows, create a user in the domain controller responsible for the domain of which the CIFS or MAPI server is a member. Choose Active Directory Users and Computers > Domain Name > Users and create the user (for example, with the name delegate_user). Alternatively, you can select an existing user. In Windows, create an SPN for the user using the setspn.exe command-line tool. The Windows Server 2003 SP1 Support Tools product CD includes this tool or you can download it from the Microsoft Download Center. With Windows Server 2008 or later, the setspn.exe tool is installed by default. The SPN: must be unique because the DC assigns the Kerberos ticket for it. cannot be used by another service. cannot be cifs/<hostname of domain controller>, or mapi/<hostname of domain controller>, which are used by the CIFS and MAPI services. To access the setspn.exe tool, open a command window on the domain controller. Then enter the command to add an SPN for the delegate user: for exampleThe next step is to grant the user access to delegate for the CIFS or MAPI service in Windows. You must perform this procedure for every server on which you want to enable RiOS SMB signing or Encrypted MAPI.
1. Note: If the Delegation tab does not appear, raise the Windows domain functionality to the Windows 2003 level or higher and create a Service Principal Name for the delegate user.
3. Click Add.
5.
6. In the Add Services dialog box, select either the CIFS or exchangeMDB service (MAPI) type for delegation and click OK.After you have performed steps 1 through 6 for every server on which you want to enable RiOS SMB signing or Encrypted MAPI, the next step is to add delegate users to the server-side Steelhead appliance.Note: For automatic delegation mode, you do not need to perform steps 1 through 6 for all servers but you must still configure one CIFS or exchangeMDB service, as this is required by the Active Directory interface. Also continue with the Steelhead appliance delegate user configuration steps that follow.
1. On the server-side Steelhead appliance, choose Configure > Optimization > Windows Domain Auth to display the Windows Domain Auth page.
Important: You can only add one delegate user per domain. A delegate user is required in each of the domains where a server is going to be optimized. Active Directory Domain Name Specify the delegation domain in which you want to make the delegate user a trusted member, for exampleNote: You cannot specify a single-label domain name (a name without anything after the dot), as in riverbed instead of riverbed.com. Specify the delegate user name. The maximum length is 20 characters. The username cannot contain any of these characters:Note: The system translates the user name into uppercase to match the registered server realm information.
3. Click Apply to apply your settings to the running configuration.
1. On the server-side Steelhead appliance, choose Configure > Optimization > Windows Domain Auth to display the Windows Domain Auth page.
Delegation Mode: Manual Select to enable transparent authentication using NTLM and provide more control to specify the exact servers to perform optimization for. When you select this mode, you must specify each server on which to delegate and sign for each domain using the Delegate-Only and Delegate-All-Except controls. Select to enable delegate user authentication and automatically discover the servers on which to delegate and sign. This eliminates the need to set up the servers on which to delegate and sign for each domain. This mode requires additional configuration. For details, see Auto-Delegation mode. Allow delegated authentication to these servers (Delegate-Only) Click to intercept the connections destined for the servers in this list. By default, this setting is enabled. Specify the file server IP addresses for SMB signed or MAPI encrypted traffic in the text box, separated by commas.Tip: You can switch between the Delegate-Only and Delegate-All-Except controls without losing the list of IP addresses for the control. Only one list is active at a time. Allow delegated authentication to all servers except the following (Delegate-All-Except) Click to intercept all of the connections except those destined for the servers in this list. Specify the file server IP addresses that do not require SMB signing or MAPI encryption in the text box, separated by commas. By default, this setting is disabled. Only the file servers that do not appear in the list are signed or encrypted.Note: You must register any servers not on this list with the domain controller or be using Auto-Delegation Mode.
3. Click Apply to apply your settings to the running configuration.
4. Click Save to save your settings permanently.Delegation mode automatically updates the delegate user in Active Directory with delegation rights to servers. The service updates the user in real-time, eliminating the need to grant the user access to delegate on every server. Auto-delegation mode also updates the server IP address if it changes.This section describes how to grant special privileges to the delegate user so they have automatic delegation rights to servers. The first step is to create a Delegate User with a Service Principal Name (SPN). The procedure to create a delegate user with an SPN is the same for both Windows DC R2 2003 and Windows DC R2 2008. Next, you must grant the delegate user the right to delegate on the domain controller. Because the procedures to grant the delegate user rights on the DC is different for Windows DC R2 2003 and Windows DC R2 2008, the procedures to do so are separate. Next, you must grant the user access to delegate for the CIFS or MAPI service in Windows for at least one server.Note: If you update the password for the delegate user in Active Directory, you must also update the account information on the Steelhead appliance. To do this, delete the old account and add a new one with the updated password.In Windows, create an SPN for the user using the setspn.exe command-line tool. The Windows Server 2003 SP1 Support Tools product CD includes this tool or you can download it from the Microsoft Download Center. With Windows Server 2008 or later, the setspn.exe tool is installed by default. The SPN: must be unique because the DC assigns the Kerberos ticket for it. cannot be used by another service. cannot be cifs/<hostname of domain controller>, or mapi/<hostname of domain controller>, which are used by the CIFS and MAPI services. To access the setspn.exe tool, open a command window on the domain controller. Then enter the command to add an SPN for the delegate user: for exampleTo grant the delegate user rights in the Controlling Security Group Policy Object (GPO) for Windows DC R2 2008
1.
2.
3.
4.
5. Click Add to display the Add User or Group dialog box.
7. Click OK to close the Group Policy Management editor.Now that the delegate user has rights in the Windows 2008 GPO, you must grant the delegate user more privileges to use auto-delegation mode. For details, see To grant the delegate user rights to modify the msDS-AllowedToDelegateTo Active Directory attribute on itself.To grant the delegate user rights in the Controlling Security Group Policy Object (GPO) in Windows 2003
3. Right-click Enable computer and user accounts to be trusted for delegation policy.
4. Click Properties.
6. Click OK to add the user name.
8. Click OK to close the Group Policy Management viewer.Now that the delegate user has rights in the Windows 2008 GPO, the next step is to grant the user access to delegate for the CIFS or MAPI service in Windows. You must perform the procedure for at least one server on which you want to enable RiOS SMB signing or Encrypted MAPI. For details, see To grant the user access to delegate.After granting the user access to delegate for at least one server, you must grant the delegate user more privileges to use auto-delegation mode. For details, see To grant the delegate user rights to modify the msDS-AllowedToDelegateTo Active Directory attribute on itself.To grant the delegate user rights to modify the msDS-AllowedToDelegateTo Active Directory attribute on itself
3. Select Default naming context > Domain DN > CN=Users > CN=<Delegate User>.
4. Right-click CN=<Delegate User> and select Properties.Read msDS-AllowedToDelegateTo Write msDS-AllowedToDelegateTo
9. Click OK.
10. On the server-side Steelhead appliance, choose Configure > Optimization > Windows Domain Auth to display the Windows Domain Auth page.
12. Click Apply to apply your settings to the running configuration.
13. Click Save to save your settings permanently.
14. Click Restart to restart the optimization service.When the CIFS or exchangeMDB service (MAPI) cannot obtain a delegate user’s credentials, this message appears: This message indicates that Login Denied is set for the delegate user for the entire day. To verify when the delegate user has permission to log in, select the Account tab in the Delegate User Properties dialog box and click Logon Hours.When the CIFS or exchangeMDB service cannot obtain permissions to access certain required user account attributes, this message appears: For details about constrained delegation, see
http://technet.microsoft.com/en-us/library/cc739587(WS.10).aspxKerberos end-to-end authentication in RiOS v7.0 and later relies on Active Directory replication to obtain machine credentials for any servers that require secure protocol optimization. The RiOS replication mechanism requires a domain user with AD replication privileges, and involves the same AD protocols used by Windows domain controllers. These procedures explain how to configure replication to use Kerberos authentication for these features:SMB signing SMB2 or SMB3 signing Encrypted MAPI and encrypted Outlook Anywhere HTTP or HTTP-based traffic Kerberos one-way trust in RiOS v8.5 provides an alternative to creating and using a specific Kerberos replication user for trust models with split resource and management Active Directory domains, such as Office 365 or other managed service providers.To enable Kerberos authentication for restricted trust environments, see To enable one-way trust using Kerberos. To join the server-side Steelhead appliance as an integrated Active Directory, see Easy Domain Authentication Configuration.For details about restricted trust configurations, see the Steelhead Appliance Deployment Guide - Protocols.
1. On the server-side Steelhead appliance, choose Configure > Optimization > Windows Domain Auth to display the Windows Domain Auth page.RiOS v7.0 and later stores authentication credentials for delegate and replication users in the secure vault. To unlock the secure vault, choose Configure > Security > Secure Vault and click Unlock Secure Vault.To migrate previously configured authentication credentials to the secure vault after upgrading to RiOS v7.0 or later from v6.5.x or earlier, enter this CLI command at the system prompt:For details, see the Riverbed Command-Line Interface Reference Manual.
Active Directory Domain Name Specify the AD domain in which you want to make the replication user a trusted member, for exampleYou cannot specify a single-label domain name (a name without anything after the dot), as in riverbed instead of riverbed.com. Specify the domain the user belongs to, if different from the Active Directory domain name. Riverbed recommends that you configure the user domain as close to the root as possible. Specify the replication user name. The user must have privileges to change the replicate directory. For details, see Granting Replication User Privileges on the DC.The user name can be an administrator. A replicate user that is an administrator already has the necessary replication privileges.The maximum user name length is 20 characters. The user name cannot contain any of these characters:Note: The system translates the user name into uppercase to match the registered server realm information. Enable Password Replication Policy Support When you deploy the server-side Steelhead appliance for optimizing traffic in a native Kerberos environment, and configure it in Active Directory integrated mode, you can optionally limit its scope when you configure a PRP in the Windows domain. In this way, the Steelhead appliance can only replicate accounts as permitted by the PRP rules. However, this can create additional administrative overhead in managing the PRP.A Windows server using Active Directory integration caches user and computer accounts performing authentication locally. The PRP is essentially a set rules describing which accounts the server is allowed to replicate.When PRP is enabled, the server-side Steelhead appliance only replicates accounts that it is allowed to as determined by PRP settings for the domain. When a user account is not cached locally, the server forwards the authentication to a writeable domain controller which does the authentication. If you allow the users password to be cached, then the server pulls that through a replication request. After the user is authenticated, the server caches the user password and handles any subsequent logins locally.Configure the replication user on the DC. Check the domain functional level. Configure PRP support on the DC.
3. Click Apply to apply your settings to the running configuration.
1. In Windows, open Active Directory Users and Computers and choose Start > Administrative Tools > Active Directory Users and Computers.
4. Click Next.
9. Click Finish if the correct groups and users appear with the permissions Replicating Directory Changes and Replicate Directory Changes All.Verify that the current domain functional level is Windows 2008. See Verifying the Domain Functional Level and Host Settings.The final step in configuring replication users is to add users to either the allowed password replication group or the denied password replication group.
1. Choose Start > Administrative Tools > Active Directory Users and Computers, select the domain name, right-click, and select Users.
2. Select either the Allowed RODC Password Replication Group or the Denied RODC Password Replication Group, select the members, and click Add.
3. Click OK.This section describes an alternative to creating and using a specific Kerberos replication user for environments with restricted security. This includes trust models with split resource and management Active Directory domains such as Office 365 or other managed service providers.For details about restricted trust configurations, see the Steelhead Appliance Deployment Guide - Protocols.Windows XP clients must use TCP for Kerberos in a one-way trust configuration. By default, Kerberos uses UDP. You must change UDP to TCP in a Registry setting.
1. To verify that the Active Directory environment has a one-way trust configuration, open Active Directory Domains and Trusts, right-click Account/Resource Domain, select Properties, and then select Trusts. From the account domain perspective, you should see an incoming trust from the resource domain. From the resource domain perspective, you should see an outgoing trust to the account domain.For details on one-way trust configurations, see Steelhead Appliance Deployment Guide - Protocols.
2. If you have not previously configured signing or eMAPI on the server-side Steelhead appliance, choose Configure > Optimization > Domain Auth Auto Config to walk through these configuration steps:Point DNS to the DNS server Join a domain Enable signing or eMAPI Configure transparent or delegation mode Configure replication Enable end-to-end Kerberos for signing or eMAPI
5. Click Apply to apply your settings to the running configuration.
7. Because the client-side Steelhead appliance has a default in-path rule that bypasses all traffic classified in the secure port label, remove port 88 to allow the Steelhead appliance to intercept Kerberos traffic instead of bypassing it.
8. Click Apply to apply your settings to the running configuration.RiOS v8.5 features a domain health tool to identify, diagnose, and report possible problems with a Steelhead appliance within a Windows domain environment. For details, see Checking Domain Health.Configuring CIFS Optimization Optimizing SMB2/3 Configuring MAPI Optimization Creating Inbound QoS Classes Viewing Current Connection Reports


This inspection reports any instances of labelled statements inside of JavaScript switch statements.
While occasionally intended, this construction is often the result of a typo.
switch(x) { case 1: case2: //typo! case 3: break; } |
| Powered by InspectionJS |


{% extends "auth/base.html" %} {% block sidebar %}
Apologies, we are down for maintenance Sorry for taking the site down, but I promise something good is coming! Come back soon and keep an eye on your email for new features and updates.
Currently Down For Maintenance. Stay Tuned!