Tekstmanipulatie, week 8

0. For people interested in n-gram techniques:

Another way of using n-grams for sorting text: M. Damashek: Aquaintance, Gauging Similarity with n-Grams, in: Science, vol. 267 (1995), pp. 843-848

Applying this method to DNA: T. Biro et. al: Application of Vector Space Techniques to DNA, in: Fractals 6, no. 3, pp. 205-210 (1998)
 
 

For a number of commands there are several man pages.  Sometimes it is useful to have a look to more than one of them, you will get additional information. Try out e.g.:

man man
man 7 man

man printf
man 3 printf

Warmly recommended literature to Perl:

Henny Klein's lecture notes: week 7, week 8, week 9.

The slides of Miles Osborne (especially the basic ones)

The Perl page of Rob Koeling  (It is highly recommended that you go trhough it! It is quick, good and fun!)

The 1. chapter ("Introduction") of Schwartz & Christiansen: Learning Perl (2nd edition), especially the "stroll through Perl" is recommended

(Library codes: 1. UB zaal Wisk.Natuurw.Tech. uwnt 174S PERL 005, photocopy only; 2. Bibl. Letteren 10.124 H05, lendable; 3. Bibl. Sociale Wetensch. 089 53 EX.2, lendable)

Historical background:

• Text and stream editor languages: ed --> vi, sed, awk
• Programing language: C (the par excellence language of Unix)

Its purpose is to solve problems that would be too hard to write in a Shell script, and too weird or short-lived of complicated to code in a traditional programming language (like Pascal or C). It is a simplified programing language very much fitted to the Unix philosophy and to common tasks one encounters when using Unix.

A Perl script is a file that

• is made executable (chmod +x)
• its first line gives the path to the Perl interpreter (similarly to what we have seen at shell scripts, week 5): #!/usr/bin/perl -w

A comment is a text that is not understood as being part of the program. In Perl, any text appearing after a # sign is understood as being a comment, until the end of the line. (If you wish to write a multi-line comment, each line should start with the # sign.)

For executing programs there are two possibilities:

• A compiler translates your program to an executable file (written in machine code): in the first step it parses it, and then it compiles it. This is the case of a C compiler (cc) for instance.
• An interpreter reads the source line by line, and executes it. This is the case of shell scripts (or the Commodores used to interpret the programs written in Basic language.)

3. Basic input and output commands
 

First line of any Perl program:

#!/usr/bin/perl -w

Statements end with a semicolon (;) (Can be omitted when the statement is the last statement of a block of file or eval, but not recommended.)

Paranthese are never required or forbidden for built-int functions.

Output:

print ("Hello word!");    # Text to be printed within double quotation marks

print "Hello word \n";    # \n stands for a new-line character

print "Hello, $name!\n";  # Prints the value of the variable $name at the given place

print "\a";            # ring the bell
 

Giving value to a variable:

$d = 17;  # the value of the variable $d should be 17

$d += 5   # add 5 to the value of d, and the result goes back to d

$d -= $n  # the value of $d is decremented by the value of $n

$d++      # suffix autoincrement (the value of d is incremented by 1, but the value of the expression is the value of d before that operation)

$++d      # prefix autoincrement (the value of d is incremented by 1, and the value of the expression is the value of d after that operation)

$d = 17; $e = ++$d; # The value of both $d and $e becomes 18: the value of $d is incremented, and THEN this values goes to $e

$d--; --$d    # suffix and prefix autodecrement (by 1)

It is important to remember that all scalar variables in Perl are either double-precision floating point values or strings. They are in fact automatically convertedback and forth

Input:

$name = <STDIN>        # The value of the scalar variable $name is read from the STandarD INput, including the closing \n

chomp($name);              # The closing \n us removed from $name (the results goes back to $name)
 

2 + 3      # addition

5.1 - 2.4  # substraction

3 * 12     # multiplication

14 / 3     # always floating point divide! so the result is: 4.666666....

2**3       # 2 to the third power

10.5 % 3.2 # modulus or remainder (10.5 gets reduced to its integer value, i.e. to 10, and 3.2 to 3, so the result will be 1).
 

Logical operators:

($a && $b)              # Logical AND: Is $a and $b true?
($a || $b)              # Logical OR: Is either $a or $b true?
!($a)                   # Logical NOT: is $a false?

Operators for strings:

"hello" . "world"    # concatenation, the result being "helloworld"

"hello" . "\n"       # the result is "hello\n"

$name eq "Tamas"     # equality of the strings: the result is true if the variable $name contains the string "Tamas"

$name ne "Tamas"     # not equal

Regular expressions

Regular expressions are so characteristics to Unix, and therefore characteristics to Perl, too (which follows very close the Unix philosophy). Here are some simple examples:

$fruit =~ /apple/    # This expression is true if the string "apple" appears as a substring within the string $fruit.

$fruit !~ /apple/    # This expression is true if the string "apple" DOES NOT appear within $fruit

$fruit =~ /$name/    # This expression is true if the string contained in the $name scalar variable appears within $fruit

Don't forget, everything is case sensitive under Unix!
 
 
 

4. Conditions and cycles (loops)
 

if

The syntax of the basic commands for conditions are:
 

if ( <expression> )
    {
       <commands>
    }
else
    {
       <commands>
    }

The expression can be something like $a == 2  or ($name1 . $name2)  eq "Tamas"  , but also a variable or another expression (like $a * $b). If the value of the expression is zero (false) then the else-branch will be executed. Otherwise the first branch gets executed.

An example:

#!/usr/bin/perl -w
print ("Please type 0 or 1 \n");
$number = <STDIN>;
chomp($number);
if ( $number )
  {print "You did not type 0 \n"}   # Either you type 1 or 00 or anything else
else
  {print " You typed 0 \n"}         # Only if you have typed exactly 0
print "Thanks for playing with me \n"

A very Perl-like construction is the following:

if ( <expression> )
    {
      <commands>
    }
elsif ( <expression> )
    {
        <commands>
    }
elsif ( <expression> )
    {
        <commands>
    }
        ...
else
    {
       <commands>
    }

where elsif is the combination of else if.

while

How to build loops?
 

while ( <expression> )
    {
        <commands>
    }

for

(From R. Koeling's page.) Perl has a for structure that mimics that of C. It has the form
 

for ( <initialise> ; <test> ; <inc> )
{
         first_action;
         second_action;
         etc
}

First of all the statement <initialise> is executed. Then while <test> is true the block of actions is executed. After each time the block is executed <inc> (incrementing) takes place. Here is an example for loop to print out the numbers 0 to 9.
 

for ($i = 0; $i < 10; ++$i)     # Start with $i = 1
                                # Do it while $i < 10
                                # Increment $i before repeating
{
        print "$i\n";
}
 

- - - - - - - - - - - - -

Here is a program that reads some input from the keyboard and won't continue until it is the correct password  (from Rob Koeling's tutorial):
 

#!/usr/local/bin/perl
print "Password? ";             # Ask for input
$a = <STDIN>;                   # Get input
chop $a;                        # Remove the newline at end
while ($a ne "fred")            # While input is wrong...
{
    print "sorry. Again? ";     # Ask again
    $a = <STDIN>;               # Get input again
    chop $a;                    # Chop off newline again
}

The curly-braced block of code is executed while the input does not equal the password. The while structure should be fairly clear, but this is the opportunity to notice
several things. First, we can we read from the standard input (the keyboard) without opening the file first. Second, when the password is entered $a is given that
value including the newline character at the end. The chop function removes the last character of a string which in this case is the newline.

To test the opposite thing we can use the until statement in just the same way. This executes the block repeatedly until the expression is true, not while it is true.

Another useful technique is putting the while or until check at the end of the statement block rather than at the beginning. This will require the presence of the do
operator to mark the beginning of the block and the test at the end. If we forgo the sorry. Again message in the above password program then it could be written like
this.
 

#!/usr/local/bin/perl
do
{
        "Password? ";           # Ask for input
        $a = <STDIN>;           # Get input
        chop $a;                # Chop off newline
}
while ($a ne "fred")            # Redo while wrong input