display pdf in asp net c# : Rotate pdf page permanently SDK application project wpf azure asp.net UWP DataScienceBook1_111-part1683

will be reported to the output. In the second entry within square 
brackets, “text” controls which columns are reported onto the out-
put. The square bracket notation is extremely powerful and some-
times a little unpredictable and confusing, so it is worth experi-
menting with. For example, how would you change that last com-
mand above to report all of the columns/fields for the matching 
rows? Or how would you request the “screenName” column in-
stead of the “text” column? What would happen if you substituted 
the number 1 in place of “text” on that command?
The next common task in working with strings is to count the num-
ber of words as well as the number of other interesting elements 
within the text. Counting the words can be accomplished in several 
ways. One of the simplest ways is to count the separators between 
the words - these are generally spaces. We need to be careful not to 
over count, if someone has mistakenly typed two spaces between a 
word, so let’s make sure to take out doubles. The str_replace_all() 
function from stringr can be used to accomplish this:
> tweetDF$modtext <- str_replace_all(text,"  "," ")
> tweetDF$textlen2 <- str_length(tweetDF$modtext)
> detach(tweetDF)
> attach(tweetDF)
> tweetDF[textlen != textlen2,]
The first line above uses the str_replace_all() function to substitute 
the one string in place of another as many times as the matching 
string appears in the input. Three arguments appear on the func-
tion above: the first is the input string, and that is tweetDF$text (al-
though we’ve referred to it just as “text because the dataframe is 
attached). The second argument is the string to look for and the 
third argument is the string to substitute in place of the first. Note 
that here we are asking to substitute one space any time that two in 
a row are found. Almost all computer languages have a function 
similar to this, although many of them only supply a function that 
replaces the first instance of the matching string. 
In the second command we have calculated a new string length 
variable based on the length of the strings where the substitutions 
have occurred. We preserved this in a new variable/field/column 
so that we can compare it to the original string length in the final 
command. Note the use of the bracket notation in R to address a 
certain subset of rows based on where the inequality is true. So 
here we are looking for a report back of all of the strings whose 
lengths changed. In the tweet data we are using here, the output 
indicated that there were seven strings that had their length re-
duced by the elimination of duplicate spaces.
Now we are ready to count the number of words in each tweet us-
ing the str_count() function. If you give it some thought, it should 
be clear that generally there is one more word than there are 
spaces. For instance, in the sentence, “Go for it,” there are two 
spaces but three words. So if we want to have an accurate count, 
we should add one to the total that we obtain from the str_count() 
function:
> tweetDF$wordCount<-(str_count(modtext," ") + 1)
> detach(tweetDF)
> attach(tweetDF)
> mean(wordCount)
110
Rotate pdf page permanently - 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 individual pages in pdf; rotate pdf pages
Rotate pdf page permanently - 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
rotate pdf pages in reader; permanently rotate pdf pages
[1] 14.24
In this last command, we’ve asked R to report the mean value of 
the vector of word counts, and we learn that on average a tweet in 
our dataset has about 14 words in it. 
Next, let’s do a bit of what computer scientists (and others) call 
“parsing.” Parsing is the process of dividing a larger unit, like a 
sentence, into smaller units, like words, based on some kind of 
rule. In many cases, parsing requires careful use of pattern match-
ing. Most computer languages accomplish pattern matching 
through the use of a strategy called “regular expressions.” A regu-
lar expression is a set of symbols used to match patterns. For exam-
ple, [a-z] is used to match any lowercase letter and the asterisk is 
used to represent a sequence of zero or more characters. So the 
regular expression “[a-z]*” means, “match a sequence of zero or 
more lowercase characters.
If we wanted to parse the retweet sequence that appears at the be-
ginning of some of the tweets, we might use a regular expression 
like this: “RT @[a-z,A-Z]*: ”. Each character up tot he square 
bracket is a “literal” that has to match exactly. Then the “[a-z,A-
Z]*” lets us match any sequence of uppercase and lowercase charac-
ters. Finally, the “: ” is another literal that matches the end of the 
sequence. You can experiment with it freely before you commit to 
using a particular expression, by asking R to echo the results to the 
command line, using the function str_match() like this:
str_match(modtext,"RT @[a-z,A-Z]*: ")
Once you are satisfied that this expression matches the retweet 
phrases properly, you can commit the results to a new column/
field/variable in the dataframe:
> tweetDF$rt <- str_match(modtext,"RT @[a-z,A-Z]*: ")
> detach(tweetDF)
> attach(tweetDF)
Now you can review what you found by echoing the new variable 
“rt” to the command line or by examining it in R-studio’s data 
browser:
> head(rt, 10)
[,1]                   
[1,] NA                     
[2,] NA                     
[3,] NA                     
[4,] NA                     
[5,] NA                     
[6,] NA                     
[7,] NA                     
[8,] "RT @SEIA: "           
[9,] NA                     
[10,] "RT @andyschonberger: "
This may be the first time we have seen the value “NA.” In R, NA 
means that there is no value available, in effect that the location is 
empty. Statisticians also call this missing data. These NAs appear 
in cases where there was no match to the regular expression that 
we provided to the function str_match(). So there is nothing wrong 
111
VB.NET PDF Page Redact Library: redact whole PDF pages in vb.net
extract, copy, paste, C#.NET rotate PDF pages, C# As String = Program.RootPath + "\\" output.pdf" ' open document inputFilePath) ' get the 1st page Dim page
pdf rotate just one page; how to rotate a pdf page in reader
VB.NET Image: How to Process & Edit Image Using VB.NET Image
this VB.NET image editor control SDK online tutorial page. NET Image Rotator Add-on to Rotate Image, VB SDK, will the original image file be changed permanently?
rotate all pages in pdf preview; how to reverse pages in pdf
here, this is an expected outcome of the fact that not all tweets 
were retweets. If you look carefully, though, you will see some-
thing else that is interesting.
R is trying to tell us something with the bracket notation. At the 
top of the list there is a notation of [,1] which signifies that R is 
showing us the first column of something. Then, each of the entries 
looks like [#,] with a row number in place of # and an empty col-
umn designator, suggesting that R is showing us the contents of a 
row, possibly across multiple columns. This seems a bit mysteri-
ous, but a check of the documentation for str_match() reveals that 
it returns a matrix as its result. This means that tweetDF$rt could 
potentially contain its own rectangular data object: In effect, the 
variable rt could itself contain than one column!
In our case, our regular expression is very simple and it contains 
just one chunk to match, so there is only one column of new data 
in tweetDF$rt that was generated form using str_match(). Yet the 
full capability of regular expressions allows for matching a whole 
sequence of chunks, not just one, and so str_match() has set up the 
data that it returns to prepare for the eventuality that each row of 
tweetDF$rt might actually have a whole list of results. 
If, for some reason, we wanted to simplify the structure of 
tweetDF$rt so that each element was simply a single string, we 
could use this command:
tweetDF$rt <- tweetDF$rt[ ,1]
This assigns to each element of tweetDF$rt the contents of the first 
column of the matrix. If you run that command and reexamine 
tweetDF$rt with head() you will find the simplified structure: no 
more column designator.
For us to be able to make some use of the retweet string we just iso-
lated, we probably should extract just the “screenname” of the indi-
vidual whose tweet got retweeted. A screenname in Twitter is like 
a username, it provides a unique identifier for each person who 
wants to post tweets. An individual who is frequently retweeted 
by others may be more influential because their postings reach a 
wider audience, so it could be useful for us to have a listing of all 
of the screennames without the extraneous stuff. This is easy to do 
with str_replace(). Note that we used str_replace_all() earlier in the 
chapter, but we don’t need it here, because we know that we are 
going to replace just one instance of each string:
tweetDF$rt<-str_replace(rt, "RT @","")
tweetDF$rt<-str_replace(rt,": ","")
> tail(rt, 1)
[,1]       
[100,] "SolarFred"
tweetDF$rt <- tweetDF$rt[ ,1]
In the first command, we substitute the empty string in place of the 
four character prefix “RT @”, while in the second command we sub-
stitute the empty string in place of the two character suffix “: “. In 
each case we assign the resulting string back to tweetDF$rt. You 
may be wondering why sometimes we create a new column or 
field when we calculate some new data while other times we do 
not. The golden rule with data columns is never to mess with the 
112
VB.NET Image: How to Create a Customized VB.NET Web Viewer by
commonly used document & image files (PDF, Word, TIFF btnRotate270: rotate image or document page in display 90 permanently burn drawn annotation on page in web
rotate pdf pages and save; how to rotate pdf pages and save permanently
C# PDF Page Redact Library: redact whole PDF pages in C#.net, ASP.
Page: Rotate a PDF Page. PDF Read. Text outputFilePath = Program.RootPath + "\\" output.pdf"; // open document inputFilePath); // get the 1st page PDFPage page
pdf reverse page order preview; rotate pages in pdf permanently
original data that was supplied. When you are working ona “de-
rived” column, i.e., one that is calculated from other data, it may 
require several intermediate steps to get the data looking the way 
you want. In this case, rt is a derived column that we extracted 
from the text field of the tweet and our goal was to reduce it to the 
bare screenname of the individual whose post was retweeted. So 
these commands, which successfully overwrite rt with closer and 
closer versions of what we wanted, were fair game for modifica-
tion. 
You may also have noticed 
the very last command. It 
seems that one of our steps, 
probably the use of 
str_match() must have 
“matrix-ized” our data 
again, so we use the column 
trick that appeared earlier in 
this chapter to flatten the ma-
trix back to a single column 
of string data. 
This would be a good point to visualize what we have obtained. 
Here we introduce two new functions, one which should seem fa-
miliar and one that is quite new:
table(as.factor(rt))
The as.factor() function is a type/mode coercion and just a new 
one in a family we have seen before. In previous chapters we used 
as.integer() and as.character() to perform other conversions. In R a 
factor is a collection of descriptive labels and corresponding 
unique identifying numbers. The identifying numbers are not usu-
ally visible in outputs. Factors are often used for dividing up a data-
set into categories. In a survey, for instance, if you had a variable 
containing the gender of a participant, the variable would fre-
quently be in the form of a factor with (at least) two distinct catego-
ries (or what statisticians call levels), male and female. Inside R, 
each of these categories would be represented as a number, but the 
corresponding label would usually be the only thing you would 
see as output. As an experiment, try running this command:
str(as.factor(rt))
This will reveal the 
“structure” of the data 
object after coercion. 
Returning to the earlier 
table(as.factor(rt)) com-
mand, the table() func-
tion takes as input one 
or more factors and re-
turns a so called contin-
gency table. This is easy to understand for use with just one factor: 
The function returns a unique list of factor “levels” (unique: mean-
ing no duplicates) along with a count of how many rows/instances 
there were of each level in the dataset as a whole. 
The screen shot on this page shows the command and the output. 
There are about 15 unique screennames of Twitter users who were 
retweeted. The highest number of times that a screenname ap-
peared was three, in the case of SEIA. The table() function is used 
more commonly to create two-way (two dimensional) contingency 
113
C# HTML5 Viewer: Load, View, Convert, Annotate and Edit Excel
able to change view orientation by clicking rotate button C# .NET, users can convert Excel to PDF document, export to HTML file and create multi-page tiff file
pdf rotate pages separately; rotate one page in pdf
How to C#: Cleanup Images
property whose value range is 0 to 255, it will permanently modify the To identify blank page through the property BlankPageDetected, if there is a blank page
reverse page order pdf online; rotate pdf page permanently
tables. We could demonstrate that here if we had two factors, so 
let’s create another factor.
Remember earlier in the chapter we noticed some tweets had texts 
that were longer than 140 characters. We can make a new variable, 
we’ll call it longtext, that will be TRUE if the original tweet was 
longer than 140 characters and FALSE if it was not:
> tweetDF$longtext <- (textlen>140)
> detach(tweetDF)
> attach(tweetDF)
The first command above has an inequality expression on the right 
hand side. This is tested for each row and the result, either TRUE 
or FALSE, is assigned to the new variable longtext. Computer scien-
tists sometimes call this a “flag” variable because it flags whether 
or not a certain attribute is present in the data. Now we can run the 
table() function on the two factors:
> table(as.factor(rt),as.factor(longtext))
FALSE TRUE
EarthTechling       0    1
FeedTheGrid         2    0
FirstSolar          1    0
GreenergyNews       1    0
RayGil              0    1
SEIA                3    0
SolarFred           0    2
SolarIndustry       1    0
SolarNovus          1    0
andyschonberger     0    2
deepgreendesign     0    1
gerdvdlogt          2    0
seia                2    0
solarfred           1    0
thesolsolution      1    0
For a two-way contingency table, the first argument you supply to 
table() is used to build up the rows and the second argument is 
used to create the columns. The command and output above give 
us a nice compact display of which retweets are longer than 140 
characters (the TRUE column) and which are not (the FALSE col-
umn). It is easy to see at a glance that there are many in each cate-
gory. So, while doing a retweet may contribute to having an extra 
long tweet, there are also many retweets that are 140 characters or 
less. It seems a little cumbersome to look at the long list of retweet 
screennames, so we will create another flag variable that indicates 
whether a tweet text contains a retweet. This will just provide a 
more compact way of reviewing which tweets have retweets and 
which do not:
> tweetDF$hasrt <- !(is.na(rt))
> detach(tweetDF)
114
How to C#: Color and Lightness Effects
Geometry: Rotate. Image Bit Depth. Color and Contrast. Cleanup Images. VB.NET How-to, VB.NET PDF, VB.NET Word, VB 4, false); //only posterize the second page of
rotate single page in pdf reader; how to rotate one page in pdf document
> attach(tweetDF)
> View(tweetDF)
The first command above uses a function we have not encountered 
bevfore: is.na(). A whole family of functions that start with “is” ex-
ists in R (as well as in other programming languages) and these 
functions provide a convenient way of testing the status or con-
tents of a data object or of a particular element of a data object. The 
is.na() function tests whether an element of the input variable has 
the value NA, which we know from earlier in the chapter is R’s 
way of showing a missing value (when a particular data element is 
empty). So the expression, is.na(rt) will return TRUE if a particular 
cell of tweetDF$rt contains the empty value NA, and false if it con-
tains some real data. If you look at the name of our new variable, 
however, which we have called “hasrt” you may see that we want 
to reverse the sense of the TRUE and FALSE that is.na() returns. To 
do that job we use the “!” character, which computers scientists 
may either call “bang” or more accurately, “not.” Using “not” is 
more accurate because the “!” character provides the Boolean NOT 
function, which changes a TRUE to a FALSE and vice versa. One 
last little thing is that the View() command causes R-Studio to 
freshen the display of the dataframe in its upper left hand pane. 
Let’s look again at retweets and long tweet texts:
> table(hasrt,longtext)
longtext
hasrt   FALSE TRUE
FALSE    76    2
TRUE     15    7
There are more than twice as many extra long texts (7) when a 
tweet contains a retweet than when it does not.
Let’s now follow the same general procedure for extracting the 
URLs from the tweet texts. As before the goal is to create a new 
string variable/column on the original dataframe that will contain 
the URLs for all of those tweets that have them. Additionally, we 
will create a flag variable that signifies whether or not each tweet 
contains a URL. Here, as before, we follow a key principle: Don’t 
mess with your original data. We will need to develop a new regu-
lar expression in order to locate an extract the URL string from in-
side of the tweet text. Actually, if you examine your tweet data in 
the R-Studio data browser, you may note that some of the tweets 
have more than one URL in them. So we will have to choose our 
function call carefully and be equally careful looking at the results 
to make sure that we have obtained what we need.
At the time when this was written, Twitter had imposed an excel-
lent degree of consistency on URLs, such that they all seem to start 
with the string “http://t.co/”. Additionally, it seems that the com-
pacted URLs all contain exactly 8 characters after that literal, com-
posed of upper and lower case letters and digits. We can use 
str_match_all() to extract these URLs using the following code:
str_match_all(text,"http://t.co/[a-z,A-Z,0-9]{8}")
We feed the tweetDF$text field as input into this function call (we 
don’t need to provide the tweetDF$ part because this dataframe is 
attached). The regular expression begins with the 12 literal charac-
ters ending with a forward slash. Then we have a regular expres-
sion pattern to match. The material within the square brackets 
matches any upper or lowercase letter and any digit. The numeral 
115
8 between the curly braces at the end say to match the previous pat-
tern exactly eight times. This yields output that looks like this:
[[6]]
[,1]                  
[1,] "http://t.co/w74X9jci"
[[7]]
[,1]                  
[1,] "http://t.co/DZBUoz5L"
[2,] "http://t.co/gmtEdcQI"
This is just an excerpt of the output, but there are a couple of impor-
tant things to note. First, note that the first element is preceded by 
the notation [[6]]. In the past when R has listed out multiple items 
on the output, we have seen them with index numbers like [1] and 
[2]. In this case, however, that could be confusing because each ele-
ment in the output could have multiple rows (as item [[7]] above 
clearly shows). So R is using double bracket notation to indicate 
the ordinal number of each chunk of data in the list, where a given 
chunk may itself contain multiple elements. 
Confusing? Let’s go at it from a different angle. Look at the output 
under the [[7]] above. As we noted a few paragraphs ago, some of 
those tweets have multiple URLs in them. The str_match_all() func-
tion handles this by creating, for every single row in the tweet data, a 
data object that itself contains exactly one column but one or possi-
bly more than one row - one row for each URL that appears in the 
tweet. So, just as we saw earlier in the chapter, we are getting back 
from a string function a complex matrix-like data object that re-
quires careful handling if we are to make proper use of it. 
The only other bit of complexity is this: What if a tweet contained 
no URLs at all? Your output from running the str_match_all() func-
tion probably contains a few elements that look like this:
[[30]]
character(0)
[[31]]
character(0)
So elements [[30]] and [[31]] of the data returned from 
str_match_all() each contain a zero length string. No rows, no col-
umns, just character(0), the so-called null character, which in many 
computer programming languages is used to “terminate” a string. 
Let’s go ahead and store the output from str_match_all() into a 
new vector on tweetDF and then see what we can do to tally up 
the URLs we have found:
> tweetDF$urlist<-str_match_all(text,+

"http://t.co/[a-z,A-Z,0-9]{8}")
> detach(tweetDF)
> attach(tweetDF)
> head(tweetDF$urlist,2)
[[1]]
116
[,1]                  
[1,] "http://t.co/ims8gDWW"
[[2]]
[,1]                  
[1,] "http://t.co/37PKAF3N"
Now we are ready to wrestle with the problem of how to tally up 
the results of our URL parsing. Unlike the situation with retweets, 
where there either was or was not a single retweet indication in the 
text, we have the possibility of zero, one or more URLs within the 
text of each tweet. Our new object “urlist” is a multi-dimensional 
object that contains a single null character, one row/column of 
character data, or one column with more than one row of character 
data. The key to summarizing this is the length() function, which 
will happily count up the number of elements in an object that you 
supply to it:
> length(urlist[[1]])
[1] 1
> length(urlist[[5]])
[1] 0
> length(urlist[[7]])
[1] 2
Here you see that double bracket notation again, used as an index 
into each “chunk” of data, where the chunk itself may have some 
internal complexity. In the case of element [[1]] above, there is one 
row, and therefore one URL. For element [[5]] above, we see a zero, 
which means that length() is telling us that this element has no 
rows in it at all. Finally, for element [[7]] we see 2, meaning that 
this element contains two rows, and therefore two URLs.
In previous work with R, we’ve gotten used to leaving the inside 
of the square brackets empty when we want to work with a whole 
list of items, but that won’t work with the double brackets:
> length(urlist[[]])
Error in urlist[[]] : invalid subscript type 'symbol'
The double brackets notation is designed to reference just a single 
element or component in a list, so empty double brackets does not 
work as a shorthand for every element in a list. So what we must 
do if we want to apply the length() function to each element in url-
ist is to loop. We could accomplish this with a for loop, as we did 
in the last chapter, using an index quantity such as “i” and substi-
tuting i into each expression like this: urlist[[i]]. But let’s take this 
opportunity to learn a new function in R, one that is generally 
more efficient for looping. The rapply() function is part of the “ap-
ply” family of functions,  and it stands for “recursive apply.” Recur-
sive in this case means that the function will dive down into the 
complex, nested structure of urlist and repetitively run a function 
for us, in this case the length() function:
> tweetDF$numurls<-rapply(urlist,length)
> detach(tweetDF)
> attach(tweetDF)
> head(numurls,10)
117
[1] 1 1 1 1 0 1 2 1 1 1
Excellent! We now have a new field on tweetDF that counts up the 
number of URLs. As a last step in examining our tweet data, let’s 
look at a contingency table that looks at the number of URLs to-
gether with the flag indicating an extra long tweet. Earlier in the 
chapter, we mentioned that the table() function takes factors as its 
input. In the command below we have supplied the numurls field 
to the table() function without coercing it to a factor. Fortunately, 
the table() function has some built in intelligence that will coerce a 
numeric variable into a factor. In this case because numurls only 
takes on the values of 0, 1, or 2, it makes good sense to allow ta-
ble() to perform this coercion:
> table(numurls,longtext)
longtext
numurls FALSE TRUE
0    16    3
1    72    6
2     3    0
This table might be even more informative if we looked at it as pro-
portions, so here is a trick to view proportions instead of counts:
> prop.table(table(numurls,longtext))
longtext
numurls FALSE TRUE
0  0.16 0.03
1  0.72 0.06
2  0.03 0.00
That looks familiar! Now, of course, we remember that we had ex-
actly 100 tweets, so each of the counts could be considered a per-
centage with no further calculation. Still, prop.table() is a useful 
function to have when you would rather view your contingency 
tables as percentages rather than counts. We can see from these re-
sults that six percent of the tweets have one URL, but only three 
percent have no URLS.
So, before we close out this chapter, let’s look at a three way contin-
gency table by putting together our two flag variables and the num-
ber of URLs:
> table(numurls,hasrt,longtext)
, , longtext = FALSE
hasrt
numurls FALSE TRUE
0    15    1
1    58   14
2     3    0
, , longtext = TRUE
hasrt
numurls FALSE TRUE
0     0    3
118
1     2    4
2     0    0
Not sure this entirely solves the mystery, but if we look at the sec-
ond two-way table above, where longtext = TRUE, it seems that ex-
tra long tweets either have a retweet (3 cases), or a single URL (2 
cases) or both (4 cases). 
When we said we would give statistics a little rest in this chapter, 
we lied just a tiny bit. Check out these results:
> mean(textlen[hasrt&longtext])
[1] 155
> mean(textlen[!hasrt&longtext])
[1] 142
In both commands we have requested the mean of the variable 
textlen, which contains the length of the original tweet (the one 
without the space stripped out). In each command we have also 
used the bracket notation to choose a particular subset of the cases. 
Inside the brackets we have a logical expression. The only cases 
that will be included in the calculation of the mean are those where 
the expression inside the brackets evaluates to TRUE. In the first 
command we ask for the mean tweet length for those tweets that 
have a retweet AND are extra long (the ampersand is the Boolean 
AND operator). In the second command we use the logical NOT 
(the “!” character) to look at only those cases that have extra long 
text but do not have a retweet. The results are instructive. The 
really long tweets, with a mean length of 155 characters, are those 
that have retweets. It seems that Twitter does not penalize an indi-
vidual who retweets by counting the number of characters in the 
“RT @SCREENNAME:” string. If you have tried the web interface 
for Twitter you will see why this makes sense: Retweeting is accom-
plished with a click, and the original tweet - which after all may al-
ready be 140 characters - appears underneath the screenname of 
the originator of the tweet. The “RT @” string does not even appear 
in the text of the tweet at that point.
Looking back over this chapter, we took a close look at some of the 
string manipulation functions provided by the package “stringr”. 
These included some of the most commonly used actions such as 
finding the length of a string, finding matching text within a string, 
and doing search and replace operations on a string. We also be-
came aware of some additional complexity in nested data struc-
tures. Although statisticians like to work with nice, well-ordered 
rectangular datasets, computer scientists often deal with much 
more complex data structures - although these are built up out of 
parts that we are familiar with such as lists, vectors, and matrices.
Twitter is an excellent source of string data, and although we have 
not yet done much in analyzing the contents of tweets or their 
meanings, we have looked at some of the basic features and regu-
larities of the text portion of a tweet. In the next chapter we will be-
come familiar with a few additional text tools and then be in a posi-
tion to manipulate and analyze text data
Chapter Challenges
Create a function that takes as input a dataframe of tweets and re-
turns as output a list of all of the retweet screennames. As an extra 
challenge, see if you can reduce that list of screennames to a 
unique set (i.e., no duplicates) while also generating a count of the 
number of times that each retweet screenname appeared.
119
Documents you may be interested
Documents you may be interested