Data conver
s
i
on
s
91
If you have a function, 
reformat
, that will change the numbers into your pre-
ferred format then you can use code like this:
$data =~ s/$num_re/reformat($1)/ge;
which makes use, once more, of the 
e
modifier to execute the replacement string
before using it.
Reforma
t
t
ing numbers wi
t
h sprin
t
f
The simplest way to reformat a number is to pass it through 
sprintf
. This will
enable you to do things like fix the number of decimal places, pad the start of the
number with spaces or zeroes, and right or left align the number within its field.
Here is an example of the sort of things that you can do:
my $number = 123.456789;
my @fmts = ('0.2f', '.2f', '10.4f', '-10.4f');
foreach (@fmts) {
my $fmt = sprintf "%$_", $number;
print "$_: [$fmt]\n";
}
which gives the following output:
0.2f: [123.46]
.2f: [123.46]
10.4f: [
123.4568]
-10.4f: [123.4568
]
(The brackets are there to show the exact start and end of each output field.)
Reforma
t
t
ing numbers wi
t
CPAN
modules
There are, however, a couple of modules available on the 
CPAN
which allow you
to do far more sophisticated formatting of numbers. They are 
Convert::SciEng
and 
Number::Format
.
Conver
t
:
:
SciEng
Convert::SciEng
is a module for converting numbers to and from a format in
which they have a postfix letter indicating the magnitude of the number. This con-
version is called fixing and unfixing the number. The module recognizes two
different schemes of fixes, the 
SI
scheme and the 
SPICE
scheme. The module inter-
face is via an object interface. A new object is created by calling the class 
new
method
and passing it a string indicating which fix scheme you want to use (
SI
or 
SPICE
).
my $conv = Convert::SciEng->new('SI');
You can then start fixing and unfixing numbers. The following:
Pdf rotate single page reader - 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#
pdf reverse page order preview; pdf reverse page order online
Pdf rotate single page reader - 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 pages separately; permanently rotate pdf pages
92
CHAPTER 
Un
s
tructured data
print $conv->unfix('2.34u');
will print the value 2.34e-06. The “u” is taken to mean the 
SI
symbol for microunits.
You can also pass an array to unfix, as in
print map { "$_\n" } $conv->unfix(qw/1P 1T 1G 1M 1K 1 1m 1u 1p 1f 1a/);
which will produce the output
1e+015
1000000000000
1000000000
1000000
1000
1
0.001
1e-006
1e-012
1e-015
1e-018
(and also demonstrates the complete range of postfixes understood by the 
SI
scheme).
You can also adjust the format in which the results are returned in by using the
format
method and passing it a new format string. The format string is simply a
string that will be passed to 
sprintf
whenever a value is required. The default for-
mat is 
%5.5g
.
There is, of course, also a 
fix
method that takes a number and returns a value
with the correct postfix letter appended:
print $conv->fix(100_000)
prints “100K” and
print $conv->fix(1_000_000)
prints “1M”.
Number
:
:
Forma
t
The 
Number::Format
module is a more general-purpose module for formatting
numbers in interesting ways. Like 
Convert::SciEng
, it is accessed through an
object-oriented interface. Calling the 
new
method creates a new formatter object.
This method takes as its argument a hash which contains various formatting
options. These options are detailed in appendix A along with the other object
methods contained within 
Number::Format
.
Here are some examples of using this module:
my $fmt = Number::Format->new; # use all defaults
my $number = 1234567.890;
VB.NET PDF Page Delete Library: remove PDF pages in vb.net, ASP.
Able to remove a single page from adobe PDF document in VB.NET. using RasterEdge. XDoc.PDF; How to VB.NET: Delete a Single PDF Page from PDF File.
pdf rotate single page; rotate pages in pdf and save
C# PDF Page Delete Library: remove PDF pages in C#.net, ASP.NET
application. Able to remove a single page from PDF document. Ability Demo Code: How to Delete a Single PDF Page from PDF File in C#.NET. How to
rotate pdf page by page; how to save a pdf after rotating pages
Data conver
s
i
on
s
93
print $fmt->round($number), "\n";
print $fmt->format_number($number), "\n";
print $fmt->format_negative($number), "\n";
print $fmt->format_picture($number, '###########'), "\n";
print $fmt->format_price($number), "\n";
print $fmt->format_bytes($number), "\n";
print $fmt->unformat_number('1,000,000.00'), "\n";
This results in:
1234567.89
1,234,567.89
-1234567.89
1234568
USD 1,234,567.89
1.18M
1000000
Changing the formatting options slightly:
my $fmt = Number::Format->new(INTL_CURRENCY_SYMBOL => 'GBP',
DECIMAL_DIGITS => 1);
my $number = 1234567.890;
print $fmt->round($number), "\n";
print $fmt->format_number($number), "\n";
print $fmt->format_negative($number), "\n";
print $fmt->format_picture($number, '###########'), "\n";
print $fmt->format_bytes($number), "\n";
print $fmt->unformat_number('1,000,000.00'), "\n";
results in:
1234567.9
1,234,567.9
-1234567.89
1234568
GBP 1,234,567.89
1.18M
1000000
If we were formatting numbers for a German system, we might try something like this:
my $de = Number::Format->new(INT_CURR_SYMBOL => 'DEM ',
THOUSANDS_SEP => '.',
DECIMAL_POINT => ',');
my $number = 1234567.890;
print $de->format_number($number), "\n";
print $de->format_negative($number), "\n";
print $de->format_price($number), "\n";
which would result in:
VB.NET PDF- View PDF Online with VB.NET HTML5 PDF Viewer
C#.NET PDF file & pages edit, C#.NET PDF pages extract, copy, paste, C#.NET rotate PDF pages, C# Users can view PDF document in single page or continue
rotate pdf page few degrees; how to rotate a pdf page in reader
How to C#: Basic SDK Concept of XDoc.PDF for .NET
insert, delete, re-order, copy, paste, cut, rotate, and save or query data and save the PDF document. The PDFPage class presents a single page in a PDFDocument
rotate all pages in pdf and save; rotate all pages in pdf preview
94
CHAPTER 
Un
s
tructured data
1.234.567,89
-1234567.89
DEM 1.234.567,89
And finally, if we were accountants, we might want to do something like this:
my $fmt = Number::Format->new(NEG_FORMAT=> '(x)');
my $debt = -12345678.90;
print $fmt->format_negative($debt);
which would give us:
(12345678.90)
It is, of course, possible to combine 
Number::Format
with some of the other tech-
niques that we were using earlier. If we had a text document that contained num-
bers in different formats and we wanted to ensure that they were all in our standard
format we could do it like this:
use Number::Format;
my $data;
{
local $/ = undef;
$data = <STDIN>;
}
my $fmt = Number::Format->new;
my $num_re = qr/[-+]?(?=\d|\.\d)\d*(\.\d*)?([eE]([-+]?\d+))?/;
$data =~ s/$num_re/$fmt->format_number($1)/ge;
print $data;
5.3
Fur
t
her informa
t
ion
For more information about input control variables such as 
$/
, see the 
perldoc
perlvar
manual pages.
For more information about the Unicode support in Perl, see the 
perldoc
perlunicode
and 
perldoc
utf8
manual pages.
For more information about 
sprintf
, see the 
perldoc
-f
sprintf
manual page.
Both 
Convert::SciEng
and 
Number::Format
can be found on the 
CPAN
.
Once you have installed them, their documentation will be available using the
perldoc
command.
C# PDF Convert to Tiff SDK: Convert PDF to tiff images in C#.net
Both single page and multipage tiff image files can be created from PDF. Supports tiff compression selection. Supports for changing image size.
how to rotate just one page in pdf; rotate pdf pages and save
VB.NET PDF: Basic SDK Concept of XDoc.PDF
insert, delete, re-order, copy, paste, cut, rotate, and save or query data and save the PDF document. The PDFPage class presents a single page in a PDFDocument
how to reverse page order in pdf; how to reverse pages in pdf
S
i
mple record-or
i
ented data
97
A very large proportion of the data that you will come across in data munging tasks
will be record oriented. In this chapter we will take a look at some common ways to
deal with this kind of data. 
6.1
Simple record
-
orien
t
ed da
t
a
We have already seen examples of simple record-oriented data. The 
CD
data file that
we examined in previous chapters had one line of data for each 
CD
in my collection.
Each of these lines of data is a record. As we will see later, a record can be larger or
smaller than one line, but we will begin by looking in more detail at files where each
line is one record. 
6.1.1 Reading simple record
-
orien
t
ed da
t
a
Perl makes it very easy to deal with record-oriented data, particularly simple records
of the type we are discussing here. We have seen before the idiom where you can
read a file a line at a time using a construct like
while (<FILE>) {
chomp; # remove newline
# each line in turn is assigned to $_
}
Let’s take a closer look and see what Perl is doing here to make life easier.
The most important part of the construct is the use of 
<FILE>
to read data from
the file handle 
FILE
which has presumably been assigned to a file earlier in the pro-
gram by a call to the 
open
function. This file input operator can return two differ-
ent results, depending on whether it is used in scalar context or array context.
When called in a scalar context, the file input operator returns the next record
from the file handle. This begs the obvious question of what constitutes a record.
The answer is that input records are separated by a sequence of characters called
(logically enough) the input record separator. This value is stored in the variable 
$/
.
The default value is a newline 
\n
(which is translated to the appropriate actual char-
acters for the specific operating system), but this can be altered to any other string of
characters. We will look at this usage in more detail later, but for now the default
value will suffice.
When called in an array context, the file input operator returns a list in which
each element is a record from the input file.
You can, therefore, call the file input operator in one of these two ways:
my $next_line = <FILE>;
my @whole_file = <FILE>;
98
CHAPTER 
Record-or
i
ented data
In both of these examples it is important to realize that each record—whether it is
the record stored in 
$next_line
or one of the records in 
@whole_file
—will still
contain the value of 
$/
at the end.1 Often you will want to get rid of this and the
easiest way to do it is by using the 
chomp
function. 
chomp
is passed either a scalar or
an array and removes the value of 
$/
from the end of the scalar or each element of
the array. If no argument is passed to chomp then it works on 
$_
.2
Reading da
t
a a record a
t
t
ime (from firs
t
principles)
Now that we understand a little more about the file input operator and 
chomp
, let’s
see if we can build our standard data munging input construct from first principles.
A first attempt at processing each line in a file might look something like this:
my $line;
while ($line = <FILE>) {
chomp $line;
}
This is a good start, but it has a subtle bug in it. The conditional expression in the
while
loop is checking for the truth of the scalar variable 
$line
. This variable is set
from the next line taken from 
FILE
. Generally this is fine, but there are certain con-
ditions when a valid line in a file can evaluate to false. The most obvious of these is
when the final line in a file contains the value 
0
(zero) and has no end of line char-
acters after it.3 In this case, the variable 
$line
will contain the value 
0
which will
evaluate as false and the final line of the file will not be processed.
Although this bug is a little obscure, it is still worthwhile finding a solution that
doesn’t exhibit this problem. This is simple enough to do by checking that the line
is defined instead of evaluating to true. The contents of a variable are said to be
defined if they are not the special Perl value 
undef
. Any variable that contains a
value that evaluates to false will still be defined. Whether or not a value is defined
can be tested using the 
defined
function. The file input operator returns 
undef
when the end of the file is reached. We can therefore rewrite our first attempt into
something like this:
1
Except, possibly, the last line in the file.
2
In versions of Perl before Perl 5, the 
chomp
function did not exist. Instead we had to use a function called
chop
, which simply removed the last character from a string without checking what it was. As this is still
an occasionally useful thing to do to a string, 
chop
is still available in Perl, but most of the time 
chomp
is
more appropriate.
3
It would have to the be last line, because for any other line, the existence of the end of line characters
following the data will ensure that there is enough data in the string for it to evaluate as true.
S
i
mple record-or
i
ented data
99
my $line;
while (defined($line = <FILE>)) {
chomp $line;
}
and this will exhibit all of the behavior that we need. There are still a couple of
improvements that we can make, but these are more about making the code Perlish
than about fixing bugs.
The first of the changes is to make use of the Perl default variable 
$_
. A lot of
Perl code can be made more streamlined by using 
$_
. In this case it makes a small
amount of difference. We no longer need to define 
$line
and we can make use of
the fact that 
chomp
works on 
$_
by default. Our code will now look like this:
while (defined($_ = <FILE>)) {
chomp;
}
The last piece of optimization is one that you wouldn’t be able to guess at, as it uses
a piece of syntactic sugar that was put in by the authors of Perl when they realized
what a common task this would be. If the file input operator is the only thing that is
in the conditional expression of a 
while
loop, then the result of the operator is
magically assigned to the 
$_
variable and the resulting value is checked to see that it
is defined (rather than checking that it is true.) This means that you can write:
while (<FILE>)) {
chomp;
}
at which point we are back with our original code (but, hopefully, with a deeper
understanding of the complexities beneath the surface of such simple looking code).
Notice that this final optimization is dependent on two things being true:
1
The file input operator must be the only thing in the conditional expres-
sion, so you can’t write things like
while (<FILE> and $_ ne 'END') { # THIS DOESN'T WORK!
}
2
The conditional expression must be part of a 
while
loop, so you can’t write
things like
if (<FILE>) { # THIS DOESN'T WORK EITHER!
print;
} else {
print "No data\n";
}
100
CHAPTER 
Record-or
i
ented data
Coun
t
ing 
t
he curren
t
record number
While looping through a file like this it is often useful to know which line you are
currently processing. This useful information is stored in the 
$.
variable.4 The value
is reset when the file handle is closed, which means that this works:
open FILE, 'input.txt' or die "Can't open input file: $!\n";
while (<FILE>) {
# do stuff
}
print "$. records processed.\n";
close FILE;
but the following code is wrong as it will always print zero.
# THIS CODE DOESN'T WORK
open FILE, "input.txt" or die "Can't open input file: $!\n";
while (<FILE>) {
# do stuff
}
close FILE;
print "$. records processed.\n";
In many of these examples, I have moved away from using 
STDIN
, simply to indi-
cate that these methods will work on any file handle. To finish this section, here is a
very short example using 
STDIN
that will add line numbers to any file passed to it.
#!/usr/local/bin/perl -w
use strict;
print "$.: $_" while <STDIN>;
6.1.2 Processing simple record
-
orien
t
ed da
t
a
So now that we know how to get our records from the input stream (either one at a
time or all together in an array) what do we do with them? Of course, the answer to
that question depends to a great extent on what your end result should be, but here
are a few ideas.
Ex
t
rac
t
ing da
t
a fields
Chances are that within your record there will be individual data items (otherwise
known as fields) and you will need to break up the record to access these fields.
Fields can be denoted in a record in a number of ways, but most methods fall into
4
Actually, 
$.
contains the current line number in the file handle that you read most recently. This allows you
to still use 
$.
if you have more than one file open. It’s also worth mentioning that the definition of a line
is determined by the contents of the input separator variable (
$/
), which we’ll cover in more detail later.
Documents you may be interested
Documents you may be interested