[24247] in Perl-Users-Digest
Perl-Users Digest, Issue: 6438 Volume: 10
daemon@ATHENA.MIT.EDU (Perl-Users Digest)
Wed Apr 21 03:15:39 2004
Date: Wed, 21 Apr 2004 00:15:14 -0700 (PDT)
From: Perl-Users Digest <Perl-Users-Request@ruby.OCE.ORST.EDU>
To: Perl-Users@ruby.OCE.ORST.EDU (Perl-Users Digest)
Perl-Users Digest Wed, 21 Apr 2004 Volume: 10 Number: 6438
Today's topics:
Re: slurp not working? ideas please! <tassilo.parseval@rwth-aachen.de>
Re: sort numeric lists <nospam@bigpond.com>
Re: sort numeric lists <bmb@ginger.libs.uga.edu>
Re: sort numeric lists <uri@stemsystems.com>
Re: sort numeric lists <jtc@shell.dimensional.com>
Re: sort numeric lists <bmb@ginger.libs.uga.edu>
Re: sort numeric lists <tassilo.parseval@rwth-aachen.de>
Re: sort numeric lists <uri@stemsystems.com>
Re: sort numeric lists <King@ask.for.email.invalid>
Digest Administrivia (Last modified: 6 Apr 01) (Perl-Users-Digest Admin)
----------------------------------------------------------------------
Date: 21 Apr 2004 06:11:42 GMT
From: "Tassilo v. Parseval" <tassilo.parseval@rwth-aachen.de>
Subject: Re: slurp not working? ideas please!
Message-Id: <c653at$7vrqh$1@ID-231055.news.uni-berlin.de>
Also sprach Geoff Cox:
> On 20 Apr 2004 21:29:05 GMT, "Tassilo v. Parseval"
><tassilo.parseval@rwth-aachen.de> wrote:
>
>>I am quite sure your program will magically start working once you
>>change it accordingly to what I've written.
>
> Tassilo,
>
> Not quite there yet - although a million thanks for the care you have
> taken to explain how wrong I was. The light is beginning to dawn!
>
> The code below brings up 2 warnings
>
> 1. use of inherited AUTOLOAD for non-method MyParser::choice() is
> deprecated at line 26 - ie
>
> choice( $attr->{ value } );
You call this inside the package MyParser, but choice() is defined in
package main. You have two options: Either calling it package-qualified:
main::choice( $attr->{ value } );
or you move the definition of choice() into MyParser. If you do the
latter but also intend to call choice() somewhere in main (I didn't
check), then you'll again have to package-qualify this call:
MyParser::choice( ... );
> 2. can't locate auto /yParser/choice.al in @INC (@INC contains:
> D:/perl/lib D:/perl/site/lib .) at line 24 - ie
>
> if ( $tagname eq 'option' ) {
>
> As warning 1 says "deprecated" I am guessing that this is not stopping
> the script? How about warning 2?
Warning 2 is in fact a fatal error and so it does terminate your script.
However, it's a follow-up to warning 1. If you fix the call to choice()
by either moving it into MyParser or package-qualifying calls to it,
this error will go away, too.
> Also, how do I deal with the print OUT in sub text?
>
> sub text {
> my ( $self, $origtext ) = @_;
> print OUT ("<h2>$origtext</h2> \n") if $in_heading;
> print OUT ("<p>$origtext</p> \n") if $in_p;
>
> At this point the file has not been opened ...?
Ah, ok. That means your class needs some additional static data
($in_heading and $in_p are already static information, btw).
Add a third variable and a method to introduce the filehandle to
MyPackage thusly:
my ($in_heading, $in_p, $fh);
...
sub register_fh {
$fh = shift;
}
# the callbacks now need to use $fh instead of OUT
sub text {
my ($self, $origtext) = @_;
print $fh "<h2>$origtext</h2>\n" if $in_heading;
print $fh "<p>$origtext</p>\n" if $in_p;
}
This creates a door to MyParser through which you can send the
filehandle to which you want the output to go. You use it inside the
File::Find::find() callback. Like this:
find sub {
my $name = $_;
open( OUT, ">>d:/a-keep9/short-nondb/short/members2/$name" ) ||
die "can't open d:/a-keep9/short-nondb/short/members2/$name: $!";
print OUT ("<html><head><title>test</title></head><body> \n");
print OUT ("<table width='100%' border='1'> \n");
$parser->register_fh(\*OUT); # filehandles are best passed by reference
$parser->parse_file($_);
$parser->reset;
}, $dir;
A note on filehandles: A filehandle (a GLOB in Perl) is the only
datatype that can be replaced by a reference where you use the reference
in place of the ordinary GLOB:
open OUT, "file" or die $!;
print OUT "foobar\n";
is very much the same as
open OUT, "file" or die $!;
my $fh = \*OUT;
print $fh "foobar\n";
or even this (works with perl5.6.0 and above):
open my $fh, "file" or die $!;
print $fh "foobar\n";
The latter is preferable because a lexical filehandle is automatically
closed when it goes out of scope.
Finally a few notes regarding your code:
> package MyParser;
> use base qw(HTML::Parser);
> use strict;
> use diagnostics;
[...]
> package main;
>
> use File::Find;
>
> my $dir = "d:/a-keep9/short-nondb/oldshort2";
> my $parser = MyParser->new;
>
> find sub {
>
> my $name = $_;
>
> open( OUT, ">>d:/a-keep9/short-nondb/short/members2/$name" );
> || die "can't open d:/a-keep9/short-nondb/short/members2/$name: $!";
The semicolon terminating the open() statement should not be there. It's
even a syntax-error.
> print OUT ("<html><head><title>test</title></head><body> \n");
> print OUT ("<table width='100%' border='1'> \n");
>
> undef $/;
Now that you use parse_file(), you no longer slurp anything and
therefore this line can be removed.
> $parser->parse_file($_);
> $parser->reset;
>
>
> }, $dir;
>
> sub choice {
> my ($path) = @_;
> if ( $path =~ /docs\/btec-first/ ) {
> intro($path);
> btecfirst($path);
> }
> elsif ( $path =~ /docs\/aslevel\/classroom-notes/ ) {
> intro($path);
> aslevelclassroomnotes($path);
> }
> elsif ( $path =~ /docs\/avce\/assignments/ ) {
> intro($path);
> avceassignments($path);
> }
[...]
> else {
> intro($path);
> other($path);
> }
>
> }
Repetitive code like that cries for shortcut. Don't do the matches
against $path (it's too much to type) but use Perl's default variable $_
here. Two ways to do that:
local $_ = $path;
if ( /docs\/btec-first/ ) {
...
}
elsif ( /docs\/aslevel\/classroom-notes/) {
...
}
...
Or wrap the whole stuff in a for-loop:
for ($path) {
if ( /docs\/btec-first/ ) {
...
}
...
else {
...
}
}
Furthermore, there are too many braces. You don't need any of them really:
local $_ = $path;
/docs\/btec-first/ and
intro($path), btecfirst($path), return;
/docs\/aslevel\/classroom-notes/ and
intro($path), ..., return;
...
The point is that for monotonous code like that, Perl offers many ways
to rewrite it. Use the most concise and most readable one. The above
suggested one has many advantages. The most important one is visual
distinctiveness: you have the condition in one line and the action to
take in case the condition was true in the line below indended. It's
easy to add new condition/action pairs and you don't need to distinguish
any longer between 'if', 'elsif' and 'else'. The order of the conditions
plus the 'return' in their action take care of that implicitely.
Apart from that, it's even a tiny bit more performant as you don't have
any blocks any longer. Perl has to pay a small price when entering a
block. Take that as an additional bonus that comes for free. Readability
should be your first concern when choosing how to write up a thing.
> sub intro {
>
> my ($pathhere) = @_;
> open( INN, "d:/a-keep9/short-nondb/db/total-160404.txt" );
> my $lineintro;
>
> while ( defined( $lineintro = <INN> ) ) {
> if ( $lineintro =~ /$pathhere','(.*?)'\)\;/ ) {
> print OUT ("<tr><td>$1 <p> </td>\n");
> }
> }
> }
>
> sub btecfirst {
>
> my ($pattern) = @_;
> my $linee = $pattern;
> my $c = 0;
> $linee =~ /.*unit(\d).*?chap(\d)/;
> my $u = $1;
> my $chap = $2;
Can you be sure that the match against $linee will always be succesfull?
Only in this case you are allowed to use $1 and $2. Otherwise they will
contain garbage from a previous match. Best is to get rid of $1 and $2
altogether:
my ($u, $chap) = $line =~ /.*unit(\d).*?chap(\d)/;
A match in list context returns the captured submatches. It returns the
empty list when the match failed.
> open( INNN, "d:/a-keep9/short-nondb/allphp/allphp2.php" );
>
> while (<INNN>) {
> last if /$pattern/;
> }
> my ( $curr, $next1, $next2, $next3 ) = <INNN>;
> close(INNN);
>
> if ( $next3 =~ /\$i\<(\d);/ ) {
> my $nn = $1;
> print OUT ("<td valign='top'>\n");
> for ( my $c = 1 ; $c < $nn ; $c++ ) {
> print OUT (
> '<a href="' . $pattern . "/unit" . $u . "-chap" .
> $chap . "-doc"
> . $c . ".zip" . '">'
> . "Document$c"
> . "</a><br>"
> . "\n" );
> }
> print OUT ("</td></tr>\n");
> }
> }
For-loops as in C are almost always frowned upon. Easier to read:
for my $c (1 .. $nn - 1) {
I am not sure about the string concatenation either. You could do it
implicitely (and also choose a different quoting mechanism because of
the literal quotes that shall appear in the string):
print OUT qq[<a href="$pattern/unit$u-chap$chap-doc$c.zip">];
print OUT qq[Document$c</a><br>\n];
This can be applied to all other functions below.
Also:
> sub aslevelclassroomnotes {
>
> sub aslevelsimulationssevern {
>
> sub asleveldebateswindfarm {
>
> sub gcsestudentactivitiesbusinesslocation {
>
> sub gcsestudentactivitiesbusinessstructuredecisions {
>
> sub gcsestudentactivitiesfinance {
>
> sub gcsestudentactivitiesmarketing {
>
> sub gcsestudentactivitiespeopleatwork {
>
> sub gcsestudentactivitiesproduction {
Isupposeyoureallylikelongfunctionnameswithnounderscoresinthem, eh? ;-)
In short: Those function names are too long. If you have long names, at
least separate its components with underscores:
sub as_level_classroom_notes {
This is still a bit long, but it's more friendly to the eye.
My experience with names is that a certain level of verbosity is
alright, but making them too verbose and chatty is going to go on your
nerves sooner or later.
Tassilo
--
$_=q#",}])!JAPH!qq(tsuJ[{@"tnirp}3..0}_$;//::niam/s~=)]3[))_$-3(rellac(=_$({
pam{rekcahbus})(rekcah{lrePbus})(lreP{rehtonabus})!JAPH!qq(rehtona{tsuJbus#;
$_=reverse,s+(?<=sub).+q#q!'"qq.\t$&."'!#+sexisexiixesixeseg;y~\n~~dddd;eval
------------------------------
Date: Wed, 21 Apr 2004 11:08:12 +1000
From: Gregory Toomey <nospam@bigpond.com>
Subject: Re: sort numeric lists
Message-Id: <2774525.KyWCscnZ2V@GMT-hosting-and-pickle-farming>
The King of Pots and Pans wrote:
> On disk I have a 2d table of numbers. Something like this:
>
> 9 8 6
> 4 5 6
>
> I read it in so that I have a list of references to lists. In other
> words, a list of the rows.
>
> I want to first sort by column 2, then column 3. When I sort by column
> 2 I get:
>
> 4 5 6
> 9 8 6
>
> As expected because 5 < 8. When I sort by column 3 I get:
>
> 9 8 6
> 4 5 6
>
> This is unexpected. Since 6 = 6, I don't want it to perform the
> sort.
Then dont.
> See how it was already sorted by column 2 when column 3 elements
> were equal, but now column 2 is unsorted again.
What are you trying to do? Partial pivoting for Gaussian elimination? Tensor
algebra?
The Perl sort function works on lists.
gtoomey
------------------------------
Date: Tue, 20 Apr 2004 21:21:17 -0400
From: Brad Baxter <bmb@ginger.libs.uga.edu>
Subject: Re: sort numeric lists
Message-Id: <Pine.A41.4.58.0404202115090.12704@ginger.libs.uga.edu>
On Wed, 21 Apr 2004, The King of Pots and Pans wrote:
> On disk I have a 2d table of numbers. Something like this:
>
> 9 8 6
> 4 5 6
>
> I read it in so that I have a list of references to lists. In other
> words, a list of the rows.
>
> I want to first sort by column 2, then column 3. When I sort by column
> 2 I get:
>
> 4 5 6
> 9 8 6
>
> As expected because 5 < 8. When I sort by column 3 I get:
>
> 9 8 6
> 4 5 6
>
> This is unexpected. Since 6 = 6, I don't want it to perform the
> sort. See how it was already sorted by column 2 when column 3 elements
> were equal, but now column 2 is unsorted again.
Typically, a sort algorithm will NOT preserve the original order when
sorting equal values. It's extra work that slows things down. It may be
unexpected, but is common. Often, sort routines offer an option that WILL
preserve original order. Perl's isn't one (that I'm aware--though I may
be mistaken).
I'm being terse in that explanation. Others may elaborate.
Regards,
Brad
------------------------------
Date: Wed, 21 Apr 2004 01:57:18 GMT
From: Uri Guttman <uri@stemsystems.com>
Subject: Re: sort numeric lists
Message-Id: <x74qreozy9.fsf@mail.sysarch.com>
>>>>> "BB" == Brad Baxter <bmb@ginger.libs.uga.edu> writes:
BB> On Wed, 21 Apr 2004, The King of Pots and Pans wrote:
>> On disk I have a 2d table of numbers. Something like this:
>>
>> 9 8 6
>> 4 5 6
>>
>> I read it in so that I have a list of references to lists. In other
>> words, a list of the rows.
>>
>> I want to first sort by column 2, then column 3. When I sort by column
>> 2 I get:
>>
>> 4 5 6
>> 9 8 6
>>
>> As expected because 5 < 8. When I sort by column 3 I get:
>>
>> 9 8 6
>> 4 5 6
>>
>> This is unexpected. Since 6 = 6, I don't want it to perform the
>> sort. See how it was already sorted by column 2 when column 3 elements
>> were equal, but now column 2 is unsorted again.
BB> Typically, a sort algorithm will NOT preserve the original order
BB> when sorting equal values. It's extra work that slows things
BB> down. It may be unexpected, but is common. Often, sort routines
BB> offer an option that WILL preserve original order. Perl's isn't
BB> one (that I'm aware--though I may be mistaken).
wrong on several counts. perl's current default sort algorithm is stable
(which means it keeps records with the same key in their original order
relative to each other). and it is not extra work to have a stable sort,
it is just a different algorithm. both the old sort (which you can still
get via a pragma) and the new one are O(N log N) on average which means
they are the same over all speed.
anyhow, the OP's problem has nothing to do with stable sorting. his
problem is that he needs to do a multikey sort and didn't know how to
specify that or do it. and of course with no code shown, who could guess
what he really did. i am using PSI::ESP and my knowledge of sorting to
figure it out. his comment on sorting by column 1 and THEN 2 and THEN 3
makes it seem like he called sort 3 separate times which is so wrong.
so if the OP wants to learn about multikey sorting in perl he should
read this:
http://www.sysarch.com/perl/sort_paper.html
and the promised module in that paper (5 years ago) is actually under
full development right now and mostly working. it is the core of a talk
i am giving at yapc::buffalo this june. the module is called Sort::Maker
and this is what the OP would do to properly sort his rows of numbers
use Sort::Maker ;
my $sorter = make_sorter(
plain => 1,
number => '$_->[0]',
number => '$_->[1]',
number => '$_->[2]',
) ;
my @sorted = $sorter->( @unsorted ) ;
i may have an alpha version of this module ready in a few weeks if
anyone is interested in playing with it. the goal is to have it on cpan
before yapc which is in mid-june.
uri
--
Uri Guttman ------ uri@stemsystems.com -------- http://www.stemsystems.com
--Perl Consulting, Stem Development, Systems Architecture, Design and Coding-
Search or Offer Perl Jobs ---------------------------- http://jobs.perl.org
------------------------------
Date: 20 Apr 2004 20:54:05 -0600
From: Jim Cochrane <jtc@shell.dimensional.com>
Subject: Re: sort numeric lists
Message-Id: <slrnc8boid.4cb.jtc@shell.dimensional.com>
In article <fdjhc.65339$U83.9813@fed1read03>, The King of Pots and Pans wrote:
> On disk I have a 2d table of numbers. Something like this:
>
> 9 8 6
> 4 5 6
>
> I read it in so that I have a list of references to lists. In other
> words, a list of the rows.
>
> I want to first sort by column 2, then column 3. When I sort by column
> 2 I get:
>
> 4 5 6
> 9 8 6
>
> As expected because 5 < 8. When I sort by column 3 I get:
>
> 9 8 6
> 4 5 6
>
> This is unexpected. Since 6 = 6, I don't want it to perform the
> sort. See how it was already sorted by column 2 when column 3 elements
> were equal, but now column 2 is unsorted again.
>
Why don't you post your code and let people help you fix it? Otherwise,
you may not get much useful help.
--
Jim Cochrane; jtc@dimensional.com
[When responding by email, include the term non-spam in the subject line to
get through my spam filter.]
------------------------------
Date: Tue, 20 Apr 2004 23:38:22 -0400
From: Brad Baxter <bmb@ginger.libs.uga.edu>
Subject: Re: sort numeric lists
Message-Id: <Pine.A41.4.58.0404202336090.12674@ginger.libs.uga.edu>
On Wed, 21 Apr 2004, Uri Guttman wrote:
> >>>>> "BB" == Brad Baxter <bmb@ginger.libs.uga.edu> writes:
>
> BB> Typically, a sort algorithm will NOT preserve the original order
> BB> when sorting equal values. It's extra work that slows things
> BB> down. It may be unexpected, but is common. Often, sort routines
> BB> offer an option that WILL preserve original order. Perl's isn't
> BB> one (that I'm aware--though I may be mistaken).
>
> wrong on several counts. perl's current default sort algorithm is stable
> (which means it keeps records with the same key in their original order
> relative to each other). and it is not extra work to have a stable sort,
> it is just a different algorithm. both the old sort (which you can still
> get via a pragma) and the new one are O(N log N) on average which means
> they are the same over all speed.
I stand corrected. I appreciate it.
Regards,
Brad
------------------------------
Date: 21 Apr 2004 06:15:42 GMT
From: "Tassilo v. Parseval" <tassilo.parseval@rwth-aachen.de>
Subject: Re: sort numeric lists
Message-Id: <c653ie$7vp3i$1@ID-231055.news.uni-berlin.de>
Also sprach Uri Guttman:
> and the promised module in that paper (5 years ago) is actually under
> full development right now and mostly working. it is the core of a talk
> i am giving at yapc::buffalo this june. the module is called Sort::Maker
> and this is what the OP would do to properly sort his rows of numbers
>
> use Sort::Maker ;
>
> my $sorter = make_sorter(
> plain => 1,
> number => '$_->[0]',
> number => '$_->[1]',
> number => '$_->[2]',
> ) ;
>
> my @sorted = $sorter->( @unsorted ) ;
>
> i may have an alpha version of this module ready in a few weeks if
> anyone is interested in playing with it. the goal is to have it on cpan
> before yapc which is in mid-june.
Ah, the mythical sort module you've been telling us so often about is
eventually going to happen! ;-)
Nice! Its interface is quite cool.
Tassilo
--
$_=q#",}])!JAPH!qq(tsuJ[{@"tnirp}3..0}_$;//::niam/s~=)]3[))_$-3(rellac(=_$({
pam{rekcahbus})(rekcah{lrePbus})(lreP{rehtonabus})!JAPH!qq(rehtona{tsuJbus#;
$_=reverse,s+(?<=sub).+q#q!'"qq.\t$&."'!#+sexisexiixesixeseg;y~\n~~dddd;eval
------------------------------
Date: Wed, 21 Apr 2004 06:22:15 GMT
From: Uri Guttman <uri@stemsystems.com>
Subject: Re: sort numeric lists
Message-Id: <x7pta1onoo.fsf@mail.sysarch.com>
>>>>> "TvP" == Tassilo v Parseval <tassilo.parseval@rwth-aachen.de> writes:
>> i may have an alpha version of this module ready in a few weeks if
>> anyone is interested in playing with it. the goal is to have it on cpan
>> before yapc which is in mid-june.
TvP> Ah, the mythical sort module you've been telling us so often about is
TvP> eventually going to happen! ;-)
not mythical, but vaporific!
i actually started it way back then but after a viscious and well
deserved code review, i shelved it. and it took this many years before i
realized the major design flaw which was trying to have key code
extraction be described by some sick data structure. now i just make the
coder pass in the code. that removed over half the complexity. and also
i have damian helping me with the api and pod so it is much more fun. :)
TvP> Nice! Its interface is quite cool.
good to hear that. it was influenced (and it influenced) the sort stuff
that damian posted to the perl 6 lang list about 2 months ago.
uri
--
Uri Guttman ------ uri@stemsystems.com -------- http://www.stemsystems.com
--Perl Consulting, Stem Development, Systems Architecture, Design and Coding-
Search or Offer Perl Jobs ---------------------------- http://jobs.perl.org
------------------------------
Date: Wed, 21 Apr 2004 07:02:18 GMT
From: The King of Pots and Pans <King@ask.for.email.invalid>
Subject: Re: sort numeric lists
Message-Id: <_%ohc.65863$U83.21047@fed1read03>
Okay some of you asked for the code. Here it is. As you can tell I am
new to perl and am trying my best. I appreciate your kind help.
I cannot use any modules that does not come with the standard perl 5.6
install, as this program will be used on a number of different
machines with just the standard install.
--- code ---
#!/usr/bin/perl -w
use strict;
my @rows = ();
my @sorted = ();
open(DATA,"sort.txt") or die "cannot open file\n";
while(<DATA>)
{
my @fields = split /\s+/;
push @rows, \@fields; # list of refs to lists
}
@sorted = sort {$a->[1] <=> $b->[1]} @rows;
@sorted = sort {$a->[2] <=> $b->[2]} @rows;
for my $fields (@sorted)
{
print join " ", @$fields, "\n";
}
close(DATA);
--- code ---
sort.txt:
6 4 9
5 3 9
The first 'sort' command produces this:
5 3 9
6 4 9
This is correct because 3 < 4. The next 'sort' command produces this:
6 4 9
5 3 9
This is undesirable, as 9 = 9 so the order of the rows is desired to
remain the way it was in the previous sort with 3 < 4.
I hope this was more clear than my original post. I apologize for not
being so clear to begin with.
The data represented is just an example. There are actually many
columns and hundreds of rows.
--
The King of Pots and Pans
------------------------------
Date: 6 Apr 2001 21:33:47 GMT (Last modified)
From: Perl-Users-Request@ruby.oce.orst.edu (Perl-Users-Digest Admin)
Subject: Digest Administrivia (Last modified: 6 Apr 01)
Message-Id: <null>
Administrivia:
#The Perl-Users Digest is a retransmission of the USENET newsgroup
#comp.lang.perl.misc. For subscription or unsubscription requests, send
#the single line:
#
# subscribe perl-users
#or:
# unsubscribe perl-users
#
#to almanac@ruby.oce.orst.edu.
NOTE: due to the current flood of worm email banging on ruby, the smtp
server on ruby has been shut off until further notice.
To submit articles to comp.lang.perl.announce, send your article to
clpa@perl.com.
#To request back copies (available for a week or so), send your request
#to almanac@ruby.oce.orst.edu with the command "send perl-users x.y",
#where x is the volume number and y is the issue number.
#For other requests pertaining to the digest, send mail to
#perl-users-request@ruby.oce.orst.edu. Do not waste your time or mine
#sending perl questions to the -request address, I don't have time to
#answer them even if I did know the answer.
------------------------------
End of Perl-Users Digest V10 Issue 6438
***************************************
