display pdf in asp net c# : Rotate one page in pdf application SDK utility azure wpf web page visual studio DataScienceBook1_18-part1693

> mode(tweetList)
[1] "list"
Hmm, this is a type of object that we have not encountered before. 
In R, a list is an object that contains other data objects, and those 
objects may be a variety of different modes/types. Contrast this 
definition with a vector: A vector is also a kind of list, but with the 
requirement that all of the elements in the vector must be in the 
same mode/type. Actually, if you dig deeply into the definitions of 
R data objects, you may realize that we have already encountered 
one type of list: the dataframe. Remember that the dataframe is a 
list of vectors, where each vector is exactly the same length. So a 
dataframe is a particular kind of list, but in general lists do not 
have those two restrictions that dataframes have (i.e., that each ele-
ment is a vector and that each vector is the same length).
So we know that tweetList is a list, but what does that list contain? 
Let’s try using the str() function to uncover the structure of the list:
str(tweetList)
Whoa! That output scrolled right off the screen. A quick glance 
shows that it is pretty repetitive, with each 20 line block being 
quite similar. So let’s use the head() function to just examine the 
first element of the list. The head() function allows you to just look 
at the first few elements of a data object. In this case we will look 
just at the first list element of the tweetList list. The command, also 
shown on the screen shot below is:
str(head(tweetList,1))
Looks pretty messy, but is simpler than it may first appear. Follow-
ing the line “List of 1,” there is a line that begins “$ :Reference 
class” and then the word ‘status’ in single quotes. In Twitter termi-
nology a “status” is a single tweet posting (it supposedly tells us 
the “status” of the person who posted it). So the author of the R 
twitteR package has created a new kind of data object, called a 
‘status’ that itself contains 10 fields. The fields are then listed out. 
For each line that begins with “..$” there is a field name and then a 
mode or data type and then a taste of the data that that field con-
tains. 
So, for example, the first field, called “text” is of type “chr” (which 
means character/text data) and the field contains the string that 
80
Rotate one page in pdf - rotate PDF page permanently in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Empower Users to Change the Rotation Angle of PDF File Page Using C#
how to permanently rotate pdf pages; rotate individual pdf pages reader
Rotate one page in pdf - VB.NET PDF Page Rotate Library: rotate PDF page permanently in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
PDF Document Page Rotation in Visual Basic .NET Class Application
pdf rotate just one page; save pdf after rotating pages
starts with, “Get the real facts on gas prices.” You can look through 
the other fields and see if you can make sense of them. There are 
two other data types in there: “logi” stands for logical and that is 
the same as TRUE/FALSE; “POSIXct” is a format for storing the 
calendar date and time. (If you’re curious, POSIX is an old unix 
style operating system, where the current date and time were 
stored as the number of seconds elapsed since 12 midnight on Janu-
ary 1, 1970.) You can see in the “created” field that this particular 
tweet was created on April 5, 2012 one second after 2:10 PM. It 
does not show what time zone, but a little detective work shows 
that all Twitter postings are coded with “coordinated universal 
time” or what is usually abbreviated with UTC. 
One last thing to peek at in this data structure is about seven lines 
from the end, where it says, “and 33 methods...” In computer sci-
ence lingo a “method” is an operation/activity/procedure that 
works on a particular data object. The idea of a method is at the 
heart of so called “object oriented programming.” One way to 
think of it is that the data object is the noun, and the methods are 
all of the verbs that work with that noun. For example you can see 
the method “getCreated” in the list: If you use the method getCre-
ated on an reference object of class ‘status’, the method will return 
the creation time of the tweet. 
If you try running the command: 
str(head(tweetList,2))
you will find that the second item in the tweetList list is structured 
exactly like the first time, with the only difference being the spe-
cific contents of the fields. You can also run:
length(tweetList)
to find out how many items are in your list. The list obtained for 
this exercise was a full 500 items long. Se we have 500 complex 
items in our list, but every item had exactly the same structure, 
with 10 fields in it and a bunch of other stuff too. That raises a 
thought: tweetList could be thought of as a 500 row structure with 
10 columns! That means that we could treat it as a dataframe if we 
wanted to (and we do, because this makes handling these data 
much more convenient as you found in the “Rows and Columns” 
chapter). 
Happily, we can get some help from R in converting this list into a 
dataframe. Here we will introduce four powerful new R functions: 
as(), lapply(), rbind(), and do.call(). The first of these, as(), performs 
a type coercion: in other words it changes one type to another type. 
The second of these, lapply(), applies a function onto all of the ele-
ments of a list. In the command below, lapply(tweetList, 
as.data.frame), applies the as.data.frame() coercion to each element 
in tweetList. Next, the rbind() function “binds” together the ele-
ments that are supplied to it into a row-by-row structure. Finally, 
the do.call() function executes a function call, but unlike just run-
ning the function from the console, allows for a variable number of 
arguments to be supplied to the function. The whole command we 
will use looks like this:
tweetDF <- do.call("rbind", lapply(tweetList, +

as.data.frame))
You might wonder a few things about this command. One thing 
that looks weird is “rbind” in double quotes. This is the required 
method of supplying the name of the function to do.call(). You 
might also wonder why we needed do.call() at all. Couldn’t we 
have just called rbind() directly from the command line? You can 
81
VB.NET PDF Page Delete Library: remove PDF pages in vb.net, ASP.
If you are looking for a solution to conveniently delete one page from your PDF document, you can use this VB.NET PDF Library, which supports a variety of PDF
rotate pdf page few degrees; how to rotate one pdf page
C# PDF File Merge Library: Merge, append PDF files in C#.net, ASP.
C# developers can easily merge and append one PDF document to document imaging toolkit, also offers other advanced PDF document page processing and
rotate pdf pages in reader; pdf save rotated pages
try it if you want, and you will find that it does provide a result, 
but not the one you want. The difference is in how the arguments 
to rbind() are supplied to it: if you call it directly, lapply() is evalu-
ated first, and it forms a single list that is then supplied to rbind(). 
In contrast, by using do.call(), all 500 of the results of lapply() are 
supplied to rbind() as individual arguments, and this allows 
rbind() to create the nice rectangular dataset that we will need. The 
advantage of do.call() is that it will set up a function call with a 
variable number of arguments in cases where we don’t know how 
many arguments will be supplied at the time when we write the 
code. 
If you run the command above, you should see in the upper right 
hand pane of R-studio a new entry in the workspace under the 
heading of “Data.” For the example we are running here, the entry 
says, “500 obs. of 10 variables.” This is just what we wanted, a nice 
rectangular data set, ready to analyze. Later on, we may need more 
than one of these data sets, so let’s create a function to accomplish 
the commands we just ran:
# TweetFrame() - Return a dataframe based on a

#                search of Twitter
TweetFrame<-function(searchTerm, maxTweets)
{
twtList<-searchTwitter(searchTerm,n=maxTweets)  
return(do.call("rbind",+

lapply(twtList,as.data.frame)))
}
There are three good things about putting this code in a function. 
First, because we put a comment at the top of the function, we will 
remember in the future what this code does. Second, if you test this 
function you will find out that the variable twtList that is created 
in the code above does not stick around after the function is fin-
ished running. This is the result of what computer scientists call 
“variable scoping.” The variable twtList only exists while the 
TweetFrame() function is running. Once the function is done, 
twtList evaporates as if it never existed. This helps us to keep our 
workspace clean and avoid collecting lots of intermediate variables  
that are not reused.
The last and best thing about this function is that we no longer 
have to remember the details of the method for using do.call(), 
rbind(), lapply(), and as.data.frame() because we will not have to 
retype these commands again: we can just call the function when-
ever we need it. And we can always go back and look at the code 
later. In fact, this would be a good reason to put in a comment just 
above the return() function. Something like this:
# as.data.frame() coerces each list element into a row

# lapply() applies this to all of the elements in twtList

# rbind() takes all of the rows and puts them together

# do.call() gives rbind() all the rows as individual elements
Now, whenever we want to create a new data set of tweets, we can 
just call TweetFrame from the R console command line like this:
lgData <- TweetFrame(“#ladygaga”, 250)
This command would give us a new dataframe “lgData” all ready 
to analyze, based on the supplied search term and maximum num-
ber of tweets.
82
VB.NET PDF File Merge Library: Merge, append PDF files in vb.net
all. This guiding page will help you merge two or more PDF documents into a single one in a Visual Basic .NET imaging application.
rotate single page in pdf reader; pdf rotate all pages
VB.NET PDF Annotate Library: Draw, edit PDF annotation, markups in
to display it. Thus, PDFPage, derived from REPage, is a programming abstraction for representing one PDF page. Annotating Process.
rotate pdf pages and save; pdf reverse page order
Let’s start to play with the tweetDF dataset that we created before. 
First, as a matter of convenience, let’s learn the attach() function. 
The attach() function saves us some typing by giving one particu-
lar dataframe priority over any others that have the same variable 
names. Normally, if we wanted to access the variables in our data-
frame, we would have to use the $ notation, like this:
tweetDF$created
But if we run attach(tweetDF) first, we can then refer to created di-
rectly, without having to type the tweetDF$ before it:
> attach(tweetDF)
> head(created,4)
[1] "2012-04-05 14:10:01 UTC" "2012-04-05 14:09:21 UTC"
[3] "2012-04-05 14:08:15 UTC" "2012-04-05 14:07:12 UTC"
Let’s visualize the creation time of the 500 tweets in our dataset. 
Wen working with time codes, the hist() function requires us to 
specify the approximate number of categories we want to see in 
the histogram:
hist(created, breaks=15, freq=TRUE)
This command yields the histogram that appears below. If we look 
along the x-axis (the horizontal), this string of tweets starts at 
about 4:20 AM and goes until about 10:10 AM, a span of roughly 
six hours.  There are 22 different bars so each bar represents about 
16 minutes - for casual purposes we’ll call it a quarter of an hour. It 
looks like there are something like 20 tweets per bar, so we are look-
ing at roughly 80 tweets per hour with the hashtag “#climate.” 
This is obviously a pretty popular topic. This distribution does not 
really have a discernible shape, although it seems like there might 
be a bit of a growth trend as time goes on, particularly starting at 
about 7:40 AM.
Take note of something very important about these data: It doesn’t 
make much sense to work with a measure of central tendency. Re-
member a couple of chapters ago when we were looking at the 
number of people who resided in different U.S. states? In that case 
it made sense to say that if State A had one million people and 
State B had three million people, then the average of these two 
states was two million people. When you’re working with time 
83
C# PDF Page Extract Library: copy, paste, cut PDF pages in C#.net
Extract PDF Pages, Copy Pages from One PDF File and Paste into Others in C#.NET Program. Free PDF document processing SDK supports PDF page extraction, copying
save pdf rotate pages; rotate pdf pages individually
C# PDF Page Delete Library: remove PDF pages in C#.net, ASP.NET
Using RasterEdge Visual C# .NET PDF page deletion component, developers can easily select one or more PDF pages and delete it/them in both .NET web and Windows
rotate pages in pdf permanently; rotate all pages in pdf
stamps, it doesn’t make a whole lot of sense to say that one tweet 
arrived at 7 AM and another arrived at 9 AM so the average is 8 
AM. Fortunately, there’s a whole area of statistics concerned with 
“arrival” times and similar phenomena, dating back to a famous 
study by Ladislaus von Bortkiewicz of horsemen who died after 
being kicked by their horses. von Bortkiewicz studied each of 14 
cavalry corps over a period of 20 years, noting when horsemen 
died each year. The distribution of the “arrival” of kick-deaths 
turns out to have many similarities to other arrival time data, such 
as the arrival of buses or subway cars at a station, the arrival of cus-
tomers at a cash register, or the occurrence of telephone calls at a 
particular exchange. All of these kinds of events fit what is known 
as a “Poisson Distribution” (named after Simeon Denis Poisson, 
who published it about half a century before von Bortkiewicz 
found a use for it). Let’s find out if the arrival times of tweets com-
prise a Poisson distribution. 
Right now we have the actual times when the tweets were posted, 
coded as a POSIX date and time variable. Another way to think 
about these data is to think of each new tweet as arriving a certain 
amount of time after the previous tweet. To figure that out, we’re 
going to have to “look back” a row in order to subtract the creation 
time of the previous tweet from the creation time of the current 
tweet. In order to be able to make this calculation, we have to make 
sure that our data are sorted in ascending order of arrival - in other 
words the earliest one first and the latest one last. To accomplish 
this, we will use the order() function together with R’s built-in 
square bracket notation. 
As mentioned briefly in the previous chapter, in R, square brackets 
allow “indexing” into a list, vector, or data frame. For example, 
myList[3] would give us the third element of myList. Keeping in 
mind that a a dataframe is a rectangular structure, really a two di-
mensional structure, we can address any element of a dataframe 
with both a row and column designator: myFrame[4,1] would give 
the fourth row and the first column. A shorthand for taking the 
whole column of a dataframe is to leave the row index empty: my-
Frame[ , 6] would give every row in the sixth column. Likewise, a 
shorthand for taking a whole row of a dataframe is to leave the col-
umn index empty: myFrame[10, ] would give every column in the 
tenth row. We can also supply a list of rows instead of just one row, 
like this: myFrame[ c(1,3,5), ] would return rows 1, 3, 5 (including 
the data for all columns, because we left the column index blank). 
We can use this feature to reorder the rows, using the order() func-
tion. We tell order() which variable we want to sort on, and it will 
give back a list of row indices in the order we requested. Putting it 
all together yields this command:
tweetDF[order(as.integer(created)), ]
Working our way from the inside to the outside of the expression 
above, we want to sort in the order that the tweets were created. 
We first coerce the variable “created” to integer - it will then truly 
be expressed in the number of seconds since 1970 - just in case 
there are operating system differences in how POSIX dates are 
sorted. We wrap this inside the order() function. The order() func-
tion will provide a list of row indices that reflects the time ordering 
we want. We use the square brackets notation to address the rows 
in tweetDF, taking all of the columns by leaving the index after the 
comma empty. 
We have a choice of what to do with the dataframe that is returned 
from this command. We could assign it back to tweetDF, which 
84
C# PDF copy, paste image Library: copy, paste, cut PDF images in
This C#.NET example describes how to copy an image from one page of PDF document and paste it into another page. // Define input and output documents.
change orientation of pdf page; rotate all pages in pdf preview
C# PDF: C# Code to Process PDF Document Page Using C#.NET PDF
for developers on how to rotate PDF page in different two different PDF documents into one large PDF C# PDF Page Processing: Split PDF Document - C#.NET PDF
rotate individual pages in pdf; pdf rotate pages separately
would overwrite our original dataframe with the sorted version. 
Or we could create a new sorted dataframe and leave the original 
data alone, like so:
sortweetDF<-tweetDF[order(as.integer(created)), ]
If you choose this method, make sure to detach() tweetDF and at-
tach() sortweetDF so that later commands will work smoothly with 
the sorted dataframe:
> detach(tweetDF)
> attach(sortweetDF)
Another option, which seems better than creating a new data-
frame, would be to build the sorting into the TweetFrame() func-
tion that we developed at the beginning of the chapter. Let’s leave 
that to the chapter challenge. For now, we can keep working with 
sortweetDF.
Technically, what we have with our created variable now is a time 
series, and because statisticians like to have convenient methods 
for dealing with time series, R has a built-in function, called diff(), 
that allows us to easily calculate the difference in seconds between 
each pair of neighboring values. Try it:
diff(created)
You should get a list of time differences, in seconds, between neigh-
boring tweets. The list will show quite a wide range of intervals, 
perhaps as long as several minutes, but with many intervals near 
or at zero. You  might notice that there are only 499 values and not 
500: This is because you cannot calculate a time difference for the 
very first tweet, because we have no data on the prior tweet. Let’s 
visualize these data and see what we’ve got:
hist(as.integer(diff(created))
As with earlier commands, we use as.integer() to coerce the time 
differences into plain numbers, otherwise hist() does not know 
how to handle the time differences. This histogram shows that the 
majority of tweets in this group come within 50 seconds or less of 
the previous tweets. A much smaller number of tweets arrive 
within somewhere between 50 and 100 seconds, and so on down 
the line. This is typical of a Poisson arrival time distribution. Un-
85
like the raw arrival time data, we could calculate a mean on the 
time differences:
> mean(as.integer(diff(created)))
[1] 41.12826
We have to be careful though, in using measures of central ten-
dency on this positively skewed distribution, that the value we get 
from the mean() is a sensible representation of central tendency. Re-
membering back to the previous chapter, and our discussion of the 
statistical mode (the most frequently occurring value), we learn 
that the mean and the mode are very different:
> library("modeest")
> mfv(as.integer(diff(created)))
[1] 0
We use the library() function to make sure that the add on package 
with the mfv() function is ready to use. The results of the mfv() 
function show that the most commonly occurring time interval be-
tween neighboring tweets is zero!
Likewise the median shows that half of the tweets have arrival 
times of under half a minute:
> median(as.integer(diff(created)))
[1] 28
In the next chapter we will delve more deeply into what it means 
when a set of data are shaped like a Poisson distribution and what 
that implies about making use of the mean.
One last way of looking at these data before we close this chapter. 
If we choose a time interval, such as 10 seconds, or 30 seconds, or 
60 seconds, we can ask the question of how many of our tweet arri-
vals occurred within that time interval. Here’s code that counts the 
number of arrivals that occur within certain time intervals:
> sum((as.integer(diff(created)))<60)
[1] 375
> sum((as.integer(diff(created)))<30)
[1] 257
> sum((as.integer(diff(created)))<10)
[1] 145
You could also think of these as ratios, for example 145/500 = 0.29. 
And where we have a ratio, we often can think about it as a prob-
ability: There is a 29% probability that the next tweet will arrive in 
10 seconds or less. You could make a function to create a whole list 
of these probabilities. Some sample code for such a function ap-
pears at the end of the chapter. Some new scripting skills that we 
have not yet covered (for example, the “for loop”) appear in this 
function, but try making sense out of it to stretch your brain. Out-
put from this function created the plot that appears below.
86
This is a classic Poisson distribution of arrival probabilities. The x-
axis contains 10 second intervals (so by the time you see the num-
ber 5 on the x-axis, we are already up to 50 seconds). This is called 
a cumulative probability plot and you read it by talking about the 
probability that the next tweet will arrive in the amount of time in-
dicated on the x-axis or less. For example, the number five on the 
x-axis corresponds to about a 60% probability on the y-axis, so 
there is a 60% probability that the next tweet will arrive in 50 sec-
onds or less. Remember that this estimate applies only to the data 
in this sample!
In the next chapter we will reexamine sampling in the context of 
Poisson and learn how to compare two Poisson distributions to 
find out which hashtag is more popular.
Let’s recap what we learned from this chapter. First, we have be-
gun to use the project features of R-studio to establish a clean envi-
ronment for each R project that we build. Second, we used the 
source code window of R-studio to build two or three very useful 
functions, ones that we will reuse in future chapters. Third, we 
practiced the skill of installing packages to extend the capabilities 
of R. Specifically, we loaded Jeff Gentry’s twitteR package and the 
other three packages it depends upon. Fourth, we put the twitteR 
package to work to obtain our own fresh data right from the web.  
Fifth, we started to condition that data, for example by creating a 
sorted list of tweet arrival times. And finally, we started to analyze 
and visualize those data, by conjecturing that this sample of arrival 
times fitted the classic Poisson distribution.
Chapter Challenge
Modify the TweetFrame() function created at the beginning of this 
chapter to sort the dataframe based on the creation time of the 
tweets. This will require taking the line of code from a few pages 
ago that has the order() function in it and adding this to the Tweet-
Frame() function with a few minor modifications. Here’s a hint: 
Create a temporary dataframe inside the function and don’t attach 
it while you’re working with it. You’ll need to use the $ notation to 
access the variable you want to use to order the rows.
Sources
http://cran.r-project.org/web/packages/twitteR/twitteR.pdf
87
http://en.wikipedia.org/wiki/Ladislaus_Bortkiewicz
http://en.wikipedia.org/wiki/Poisson_distribution
http://hashtags.org
http://www.khanacademy.org/math/probability/v/poisson-proc
ess-1
http://www.khanacademy.org/math/probability/v/poisson-proc
ess-2
https://support.twitter.com/articles/49309
(hashtags explained)
http://www.rdatamining.com/examples/text-mining
R Script - Create Vector of Probabilities From Arrival Times
# ArrivalProbability - Given a list of arrival times
# calculates the delays between them using lagged differences
# then computes a list of cumulative probabilities of arrival
# for the sequential list of time increments
# times - A sorted, ascending list of arrival times in POSIXct
# increment - the time increment for each new slot, e.g. 10 sec
# max - the highest time increment, e.g., 240 sec
#
# Returns - an ordered list of probabilities in a numeric vector
# suitable for plotting with plot()
ArrivalProbability<-function(times, increment, max)
{
# Initialize an empty vector
plist <- NULL
# Probability is defined over the size of this sample
# of arrival times
timeLen <- length(times)
# May not be necessary, but checks for input mistake
if (increment>max) {return(NULL)}
for (i in seq(increment, max, by=increment))
{
# diff() requires a sorted list of times
88
# diff() calculates the delays between neighboring times
# the logical test <i provides a list of TRUEs and FALSEs
# of length = timeLen, then sum() counts the TRUEs.
# Divide by timeLen to calculate a proportion
plist<-c(plist,(sum(as.integer(diff(times))<i))/timeLen)
}
return(plist)
}
R Functions Used in This Chapter
attach() - Makes the variables of a dataset available without $ 
as.integer() - Coerces data into integers
detach() - Undoes an attach function
diff() - Calculates differences between neighboring rows
do.call() - Calls a function with a variable number of arguments
function() - Defines a function for later use
hist() - Plots a histogram from a list of data
install.packages() - Downloads and prepares a package for use
lapply() - Applies a function to a list
library() - Loads a package for use; like require()
mean() - Calculates the arithmetic mean of a vector
median() - Finds the statistical center point of a list of numbers 
mfv() - Most frequent value; part of the modeest() package
mode() - Shows the basic data type of an object
order() - Returns a sorted list of index numbers 
rbind() - Binds rows into a dataframe object
require() - Tests if a package is loaded and loads it if needed
searchTwitter() - Part of the twitteR package
str() - Describes the structure of a data object
sum() - Adds up a list of numbers
89
Documents you may be interested
Documents you may be interested