display pdf in asp net c# : How to rotate all pages in pdf in preview software control cloud windows azure html class DataScienceBook1_112-part1684

Once you have written that function, it should be a simple matter 
to copy and modify it to create a new function that extracts a 
unique list of hashtags from a dataframe of tweets. Recall that 
hashtags begin with the “#” character and may contain any combi-
nation of upper and lowercase characters as well as digits. There is 
no length limit on hashtags, so you will have to assume that a hash-
tag ends when there is a space or a punctuation mark such as a 
comma, semicolon, or period.
Sources
http://cran.r-project.org/web/packages/stringr/index.html
http://en.wikipedia.org/wiki/ASCII
http://en.wikipedia.org/wiki/Regular_expression
http://en.wikipedia.org/wiki/Unicode
http://had.co.nz
/ (Hadley Wickham)
http://mashable.com/2010/08/14/twitter-140-bug/
http://stat.ethz.ch/R-manual/R-devel/library/base/html/search
.html
http://stat.ethz.ch/R-manual/R-devel/library/base/html/table.h
tml
R Code for TweetFrame() Function
# TweetFrame() - Return a dataframe based on a search of Twit-
ter
TweetFrame<-function(searchTerm, maxTweets)
{
tweetList <- searchTwitter(searchTerm, n=maxTweets)
# 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 rows as individual elements
tweetDF<- do.call("rbind", lapply(tweetList,as.data.frame))
# This last step sorts the tweets in arrival order
return(tweetDF[order(as.integer(tweetDF$created)), ])
}
120
How to rotate all pages in pdf in preview - 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#
rotate single page in pdf file; rotate a pdf page
How to rotate all pages in pdf in preview - 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
how to save a pdf after rotating pages; rotate pdf pages individually
In the previous chapter we mastered some of the most basic and important functions for examining 
and manipulating text. Now we are in a position to analyze the actual words that appear in text 
documents. Some of the most basic functions of the Internet, such as keyword search, are 
accomplished by analyzing the “content” i.e., the words in a body of text.
CHAPTER 13
121
Word Perfect
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
Also a preview component enables compressing and decompressing in preview in ASP.NET All object data. VB.NET Demo Code to Optimize An Exist PDF File in Visual
rotate individual pages in pdf reader; how to rotate just one page in pdf
How to C#: Preview Document Content Using XDoc.Word
if (bmp == null) throw new Exception("fail to load the document preview"); //. Copyright © <2000-2016> by <RasterEdge.com>. All Rights Reserved.
pdf page order reverse; pdf rotate single page
The picture at the start of this chapter is a so called “word cloud” 
that was generated by examining all of the words returned from a 
Twitter search of the term “data science” (using a web application 
at http://www.jasondavies.com
)  These colorful word clouds are 
fun to look at, but they also do contain some useful information. 
The geometric arrangement of words on the figure is partly ran-
dom and partly designed and organized to please the eye. Same 
with the colors. The font size of each word, however, conveys some 
measure of its importance in the “corpus” of words that was pre-
sented to the word cloud graphics program. Corpus, from the 
Latin word meaning “body,” is a word that text analysts use to re-
fer to a body of text material, often consisting of one or more docu-
ments. When thinking about a corpus of textual data, a set of docu-
ments could really be anything: web pages, word processing docu-
ments on your computer, a set of Tweets, or government reports. In 
most cases, text analysts think of a collection of documents, each of 
which contains some natural language text, as a corpus if they plan 
to analyze all the documents together.
The word cloud on the previous page shows that “Data” and “Sci-
ence” are certainly important terms that came from the search of 
Twitter, but there are dozens and dozens of less important, but per-
haps equally interesting, words that the search results contained. 
We see words like algorithms, molecules, structures, and research, 
all of which could make sense in the context of data science. We 
also see other terms, like #christian, Facilitating, and Coordinator, 
that don’t seem to have the same obvious connection to our origi-
nal search term “data science.” This small example shows one of 
the fundamental challenges of natural language processing and the 
closely related area of search: ensuring that the analysis of text pro-
duces results that are relevant to the task that the user has in mind.
In this chapter we will use some new R packages to extend our 
abilities to work with text and to build our own word cloud from 
data retrieved from Twitter. If you have not worked on the chapter 
“String Theory” that precedes this chapter, you should probably 
do so before continuing, as we build on the skills developed there. 
Depending upon where you left off after the previous chapter, you 
will need to retrieve and pre-process a set of tweets, using some of 
the code you already developed, as well as some new code. At the 
end of the previous chapter, we have provided sample code for the 
TweetFrame() function, that takes a search term and a maximum 
tweet limit and returns a time-sorted dataframe containing tweets. 
Although there are a number of comments in that code, there are 
really only three lines of functional code thanks to the power of the 
twitteR package to retrieve data from Twitter for us.  For the activi-
ties below, we are still working with the dataframe that we re-
trieved in the previous chapter using this command:
tweetDF <- TweetFrame("#solar",100)
This yields a dataframe, tweetDF, that contains 100 tweets with the 
hashtag #solar, presumably mostly about solar energy and related 
“green” topics. Before beginning our work with the two new R 
packages, we can improve the quality of our display by taking out 
a lot of the junk that won’t make sense to show in the word cloud. 
To accomplish this, we have authored another function that strips 
out extra spaces, gets rid of all URL strings, takes out the retweet 
header if one exists in the tweet, removes hashtags, and eliminates 
references to other people’s tweet handles. For all of these transfor-
mations, we have used string replacement functions from the 
stringr package that was introduced in the previous chapter. As an 
example of one of these transformations, consider this command, 
122
How to C#: Preview Document Content Using XDoc.PowerPoint
if (bmp == null) throw new Exception("fail to load the document preview"); //. Copyright © <2000-2016> by <RasterEdge.com>. All Rights Reserved.
pdf rotate one page; save pdf rotated pages
C# WinForms Viewer: Load, View, Convert, Annotate and Edit PDF
Erase PDF pages. Miscellaneous. Plenty of VB.NET class demo codes and tutorials are given on How to Use XDoc.PDF SDK in VB.NET program. All Rights Reserved.
how to rotate a single page in a pdf document; how to rotate all pages in pdf at once
which appears as the second to last line of the CleanTweet() func-
tion:
tweets <- str_replace_all(tweets,"@[a-z,A-Z]*","")
You should feel pretty comfortable reading this line of code, but if 
not, here’s a little more practice. The left hand side is easy: we use 
the assignment arrow to assign the results of the right hand side 
expression to a data object called “tweets.” Note that when this 
statement is used inside the function as shown at the end of the 
chapter, “tweets” is a temporary data object, that is used just 
within CleanTweets() after which it disappears automatically. 
The right hand side of the expression uses the str_replace_all() func-
tion from the stringr package. We use the “all” function rather than 
str_replace() because we are expecting multiple matches within 
each individual tweet. There are three arguments to the str_re-
place_all() function. The first is the input, which is a vector of char-
acter strings (we are using the temporary data object “tweets” as 
the source of the text data as well as its destination), the second is 
the regular expression to match, and the third is the string to use to 
replace the matches, in this case the empty string as signified by 
two double quotes with nothing between them. The regular expres-
sion in this case is the at sign, “@”, followed by zero or more upper 
and lowercase letters. The asterisk, “*”, after the stuff in the square 
brackets is what indicates the zero or more. That regular expres-
sion will match any screenname referral that appears within a 
tweet.
If you look at a few tweets you will find that people refer to each 
other quite frequently by their screennames within a tweet, so @So-
larFred might occur from time to time within the text of a tweet. 
Here’s something you could  investigate on your own: Can screen-
names contain digits as well as letters? If so, how would you have 
to change the regular expression in order to also match the digits 
zero through nine as part of the screenname? On a related note, 
why did we choose to strip these screen names out of our tweets? 
What would the word cloud look like if you left these screennames 
in the text data?
Whether you typed in the function at the end of this chapter or you 
plan to enter each of the cleaning commands individually, let’s be-
gin by obtaining a separate vector of texts that is outside the origi-
nal dataframe:
> cleanText<-tweetDF$text
> head(cleanText, 10)
There’s no critical reason for doing this except that it will simplify 
the rest of the presentation. You could easily copy the tweetDF$text 
data into another column in the same dataframe if you wanted to. 
We’ll keep it separate for this exercise so that we don’t have to 
worry about messing around with the rest of the dataframe. The 
head() command above will give you a preview of what you are 
starting with. Now let’s run our custom cleaning function:
> cleanText<-CleanTweets(cleanText)
> head(cleanText, 10)
Note that we used our “cleanText” data object in the first com-
mand above as both the source and the destination. This is an old 
computer science trick for cutting down on the number of tempo-
rary variables that need to be used. In this case it will do exactly 
what we want, first evaluating the right hand side of the expres-
123
C# WPF Viewer: Load, View, Convert, Annotate and Edit PDF
Erase PDF pages. Miscellaneous. Plenty of VB.NET class demo codes and tutorials are given on How to Use XDoc.PDF SDK in VB.NET program. All Rights Reserved.
rotate pages in pdf; rotate one page in pdf reader
C# PDF Page Insert Library: insert pages into PDF file in C#.net
as how to merge PDF document files by C# code, how to rotate PDF document page This C# demo explains how to insert empty pages to a specific All Rights Reserved
rotate pdf page few degrees; rotate pdf page and save
sion by running our CleanTweets() function with the cleanText ob-
ject as input and then taking the result that is returned by CleanT-
weets() and assigning it back into cleanText, thus overwriting the 
data that was in there originally. Remember that we have license to 
do whatever we want to cleanText because it is a copy of our origi-
nal data, and we have left the original data intact (i.e., the text col-
umn inside the tweetDF dataframe).
The head() command should now show a short list of tweets with 
much of the extraneous junk filtered out. If you have followed 
these steps, cleanText is now a vector of character strings (in this 
example exactly 100 strings) ready for use in the rest of our work 
below. We will now use the “tm” package to process our texts. The 
“tm” in this case refers to “text mining,” and is a popular choice 
among the many text analysis packages available in R. By the way, 
text mining refers to the practice of extracting useful analytic infor-
mation from corpora of text (corpora is the plural of corpus). Al-
though some people use text mining and natural language process-
ing interchangeably, there are probably a couple subtle differences 
worth considering. First, the “mining” part of text mining refers to 
an area of practice that looks for unexpected patterns in large data 
sets, or what some people refer to as knowledge discovery in data-
bases. In contrast, natural language processing reflects a more gen-
eral interest in understanding how machines can be programmed 
(or learn on their own) how to digest and make sense of human lan-
guage. In a similar vein, text mining often focuses on statistical ap-
proaches to analyzing text data, using strategies such as counting 
word frequencies in a corpus. In natural language processing, one 
is more likely to hear consideration given to linguistics, and there-
fore to the processes of breaking text into its component grammati-
cal pieces such as nouns and verbs. In the case of the “tm” add on 
package for R, we are definitely in the statistical camp, where the 
main process is to break down a corpus into sequences of words 
and then to tally up the different words and sequences we have 
found. 
To begin, make sure that the tm package is installed and “library-
ed” in your copy of R and R-Studio. You can use the graphic inter-
face in R-Studio for this purpose or the EnsurePackage() function 
that we wrote in a previous chapter.  Once the tm package is ready 
to use, you should be able to run these commands:
> tweetCorpus<-Corpus(VectorSource(cleanText))
> tweetCorpus
A corpus with 100 text documents
> tweetCorpus<-tm_map(tweetCorpus, tolower)
> tweetCorpus<-tm_map(tweetCorpus, removePunctuation)
> tweetCorpus<-tm_map(tweetCorpus,removeWords,+

stopwords('english'))
In the first step above , we “coerce” our cleanText vector into a cus-
tom “Class” provided by the tm package and called a “Corpus,” 
storing the result in a new data object called “tweetCorpus.” This 
is the first time we have directly encountered a “Class.” The term 
“class” comes from an area of computer science called “object ori-
ented programming.” Although R is different in many ways from 
object-oriented languages such as Java, it does contain many of the 
most fundamental features that define an object oriented language. 
For our purposes here, there are just a few things to know about a 
class. First, a class is nothing more or less than a definition for the 
structure of a data object. Second, classes use basic data types, such 
124
C# HTML5 Viewer: Load, View, Convert, Annotate and Edit Raster
NET RasterEdge HTML5 Viewer offers user the functionality to rotate images 90 images to Tiff (.tif, .tiff) online, create PDF document from All Rights Reserved
rotate single page in pdf; reverse page order pdf
C# TIFF: TIFF Editor SDK to Read & Manipulate TIFF File Using C#.
Here we list all features supported by RasterEdge C#.NET to process Tiff file and its pages, like merge append, split, extract, create, insert, rotate, sort, etc
reverse pdf page order online; rotate pdf page by page
as numbers, to build up more complex data structures. For exam-
ple, if we made up a new “Dashboard” class, it could contain one 
number for “Miles Per Hour,” another number for “RPM,” and per-
haps a third one indicating the remaining “Fuel Level.” That brings 
up another point about Classes: users of R can build their own. In 
this case, the author of the tm package, Ingo Feinerer, created a 
new class, called Corpus, as the central data structure for text min-
ing functions. (Feinerer is a computer science professor who works 
at the Vienna University of Technology in the Database and Artifi-
cial Intelligence Group.) Last, and most important for this discus-
sion, a Class not only contains definitions about the structure of 
data, it also contains references to functions that can work on that 
Class. In other words, a Class is a data object that carries with it in-
structions on how to do operations on it, from simple things like 
add and subtract all the way up to complicated operations such as 
graphing.
In the case of the tm package, the Corpus Class defines the most 
fundamental object that text miners care about, a corpus contain-
ing a collection of documents. Once we have our texts stored in a 
Corpus, the many functions that the tm package provides to us are 
available. The last three commands in the group above show the 
use of the tm_map() function, which is one of the powerful capabili-
ties provided by tm. In each case where we call the tm_map() func-
tion, we are providing tweetCorpus as the input data, and then we 
are providing a command that undertakes a transformation on the 
corpus. We have done three transformations here, first making all 
of the letters lowercase, then removing the punctuation, and finally 
taking out the so called “stop” words.
The stop words deserve a little explanation. Researchers who devel-
oped the early search engines for electronic databases found that 
certain words interfered with how well their search algorithms 
worked. Words such as “the,” “a,” and “at” appeared so com-
monly in so many different parts of the text that they were useless 
for differentiating between documents. The unique and unusual 
nouns, verbs, and adjectives that appeared in a document did a 
much better job of setting a document apart from other documents 
in a corpus, such that researchers decided that they should filter 
out all of the short, commonly used words. The term “stop words” 
seems to have originated in the 1960s to signify words that a com-
puter processing system would throw out or “stop using” because 
they had little meaning in a data processing task. To simplify the 
removal of stop words, the tm package contains lists of such words 
for different languages. In the last command on the previous page 
we requested the removal of all of the common stop words.
At this point we have processed our corpus into a nice uniform 
“bag of words” that contains no capital letters, punctuation, or 
stop words. We are now ready to conduct a kind of statistical analy-
sis of the corpus by creating what is known as a “term-document 
matrix.” The following command from the tm package creates the 
matrix:
> tweetTDM<-TermDocumentMatrix(tweetCorpus)
> tweetTDM
A term-document matrix (375 terms, 100 documents)
Non-/sparse entries: 610/36890
Sparsity           : 98%
125
VB.NET PDF File Split Library: Split, seperate PDF into multiple
limit the pages of each file to 8 pages options.MaxPages = 8 outputFileName + "_" + i.ToString() + ".pdf") Next ' Split input PDF file to All Rights Reserved.
how to reverse page order in pdf; how to rotate pdf pages and save
VB.NET PDF remove image library: remove, delete images from PDF in
pages extract, copy, paste, C#.NET rotate PDF pages, C#.NET Remove multiple or all image objects from PDF Remove PDF image in preview without adobe PDF reader
rotate all pages in pdf and save; pdf rotate single page reader
Maximal term length: 21 
Weighting          : term frequency (tf)
A term-document matrix, also sometimes called a document-term 
matrix, is a rectangular data structure with terms as the rows and 
documents as the columns (in other uses you may also make the 
terms as columns and documents as rows). A term may be a single 
word, for example, “biology,” or it could also be a compound 
word, such as “data analysis.” The process of determining whether 
words go together in a compound word can be accomplished statis-
tically by seeing which words commonly go together, or it can be 
done with a dictionary. The tm package supports the dictionary ap-
proach, but we have not used a dictionary in this example. So if a 
term like “data” appears once in the first document, twice in the 
second document, and not at all in the third document, then the col-
umn for the term data will contain 1, 2, 0.
The statistics reported when we ask for tweetTDM on the com-
mand line give us an overview of the results. The TermDocument-
Matrix() function extracted 375 different terms from the 100 tweets. 
The resulting matrix mainly consists of zeros: Out of 37,500 cells in 
the matrix, only 610 contain non-zero entries, while 36,890 contain 
zeros. A zero in a cell means that that particular term did not ap-
pear in that particular document. The maximal term length was 21 
words, which an inspection of the input tweets indicates is also the 
maximum word length of the input tweets. Finally, the last line, 
starting with “Weighting” indicates what kind of statistic was 
stored in the term-document matrix. In this case we used the de-
fault, and simplest, option which simply records the count of the 
number of times a term appears across all of the documents in the 
corpus. You can peek at what the term-document matrix contains 
by using the inspect function:
inspect(tweetTDM)
Be prepared for a large amount of output. Remember the term 
“sparse” in the summary of the matrix? Sparse refers to the over-
whelming number of cells that contain zero - indicating that the 
particular term does not appear in a given document. Most term 
document matrices are quite sparse. This one is 98% sparse be-
cause 36890/37500 = 0.98. In most cases we will need to cull or fil-
ter the term-document matrix for purposes of presenting or visual-
izing it. The tm package provides several methods for filtering out 
sparsely used terms, but in this example we are going to leave the 
heavy lifting to the word cloud package.
As a first step we need to install and library() the “wordcloud” 
package. As with other packages, either use the package interface 
in R-Studio or the EnsurePackage() function that we wrote a few 
chapters ago. The wordcloud package was written by freelance stat-
istician Ian Fellows, who also developed the “Deducer” user inter-
face for R. Deducer provides a graphical interface that allows users 
who are more familiar with SPSS or SAS menu systems to be able 
to use R without resorting to the command line.
Once the wordcloud package is loaded, we need to do a little 
preparation to get our data ready to submit to the word cloud gen-
erator function. That function expects two vectors as input argu-
ments, the first a list of the terms, and the second a list of the fre-
quencies of occurrence of the terms. The list of terms and frequen-
cies must be sorted with the most frequent terms appearing first. 
To accomplish this we first have to coerce our tweet data back into 
126
a plain data matrix so that we can sort it by frequency. The first 
command below accomplishes this:
> tdMatrix <- as.matrix(tweetTDM)
> sortedMatrix<-sort(rowSums(tdMatrix),+

decreasing=TRUE)
> cloudFrame<-data.frame( +

word=names(sortedMatrix),freq=sortedMatrix)
> wordcloud(cloudFrame$word,cloudFrame$freq)
In the next command above, we are accomplishing two things in 
one command: We are calculating the sums across each row, which 
gives us the total frequency of a term across all of the different 
tweets/documents. We are also sorting the resulting values with 
the highest frequencies first. The result is a named list: Each item of 
the list has a frequency and the name of each item is the term to 
which that frequency applies.
In the second to last command above, we are extracting the names 
from the named list in the previous command and binding them 
together into a dataframe with the frequencies. This dataframe, 
“cloudFrame”, contains exactly the same information as the named 
list. “sortedMatrix,” but cloudFrame has the names in a separate 
column of data. This makes it easier to do the final command 
above, which is the call to the wordcloud() function. The word-
cloud() function has lots of optional parameters for making the 
word cloud more colorful, controlling its shape, and controlling 
how frequent an item must be before it appears in the cloud, but 
we have used the default settings for all of these parameters for the 
sake of simplicity. We pass to the wordcloud() function the term 
list and frequency list that we bound into the dataframe and word-
cloud() produces the nice graphic that you see below.  
If you recall the Twitter search that we used to retrieve those 
tweets (#solar) it makes perfect sense that “solar” is the most fre-
quent term (even though we filtered out all of the hashtags. The 
next most popular term is “energy” and after that there are a vari-
ety of related words such as “independence,” “green,” “wind,” 
and “metering.”
127
Chapter Challenge
Develop a function that builds upon previous functions we have 
developed, such as TweetFrame() and CleanTweets(), to take a 
search term, conduct a Twitter search, clean up the resulting texts, 
formulate a term-document matrix, and submit resulting term fre-
quencies to the wordcloud() function. Basically this would be a 
“turnkey” package that would take a Twitter search term and pro-
duce a word cloud from it, much like the Jason Davies site de-
scribed at the beginning of this chapter. 
Sources Used in This Chapter
http://cran.r-project.org/web/packages/wordcloud/wordcloud.
pdf
http://www.dbai.tuwien.ac.at/staff/feinerer/
http://en.wikipedia.org/wiki/Document-term_matrix
http://en.wikipedia.org/wiki/Stop_words
http://en.wikipedia.org/wiki/Text_mining
http://stat.ethz.ch/R-manual/R-devel/library/base/html/colSu
ms.html
http://www.jasondavies.com/wordcloud/
R Code for CleanTweets() Function
# CleanTweets() - Takes the junk out of a vector of
# tweet texts
CleanTweets<-function(tweets)
{
# Remove redundant spaces
tweets <- str_replace_all(tweets,"  "," ")
# Get rid of URLs
tweets <- str_replace_all(tweets, + 

"http://t.co/[a-z,A-Z,0-9]{8}","")
# Take out retweet header, there is only one
tweets <- str_replace(tweets,"RT @[a-z,A-Z]*: ","")
# Get rid of hashtags
tweets <- str_replace_all(tweets,"#[a-z,A-Z]*","")
# Get rid of references to other screennames
tweets <- str_replace_all(tweets,"@[a-z,A-Z]*","")
return(tweets)
}
128
Before now we have only used small amount of data that we typed in ourselves, or somewhat larger 
amounts that we extracted from Twitter. The world is full of other sources of data, however, and we 
need to examine how to get them into R, or at least how to make them accessible for manipulation in 
R. In this chapter, we examine various ways that data are stored, and how to access them.
CHAPTER 14
129
Storage Wars
Documents you may be interested
Documents you may be interested