Hi David.

This should do the trick, although without sight of your
original data structure I can't be sure. I assume you
have a hash of array references.

This works by grabbing a list of all the hash keys
into an array and then executing two nested loops.
The outer loop shifts the first key value off the
array (y1) and assigns it to $ya. The inner loop
just cycles $yb through the remaining values in the
list (y2, y3 etc). Next time around the outer loop
the next value (y2) is assigned to $ya and $yb will
be set to y3, y4 etc. The very inner loop just scans
through the data calculating the sum of squared
differences for each value pair and stuffs the answer
into hash %results using a key formed by concatenating
$ya and $yb.

I haven't tested this as it would be a pain to set up
some data, so I'll let you test it for me. I know it
compiles OK!

HTH,

Rob


use strict;
use warnings;

my %data;
my @keys = keys %data;
my %results;

while ( @keys ) {

my $ya = shift @keys;

foreach my $yb (@keys) {

my @xa = @{$data{$ya}};
my @xb = @{$data{$yb}};

for (my $i = 0; $i < @xa and $i < @xb; ++$i) {

$results{$ya.$yb} += ($xa[$i] - $xb[$i]) * ($xa[$i] - $xb[$i]);
}
}
}

I hope you've got a good book or two, such as "Learning Perl" (the llama
book) published by O'Reilly.

The basic setup you'll want to use is this:

open INPUT, "< in.txt" or die "can't read in.txt: $!";
open OUTPUT, "> out.txt" or die "can't write out.txt: $!";
while (my $line = <INPUT>) {
# do something to $line
print OUTPUT $line;
}
close OUTPUT;
close INPUT;

--
Jeff "japhy" Pinyan [Email Removed] http://www.pobox.com/~japhy/
RPI Acacia brother #734 http://www.perlmonks.org/ http://www.cpan.org/
<stu> what does y/// stand for? <tenderpuss> why, yansliterate of course.
[ I'm looking for programming work. If you like my work, let me know. ]

Right here you have alraedy stored the array reference to $array, so when
you foreach over the array you are actually getting each element (detail
line) into $i. So...

In the above you are trying to index into an array using the value from that
array rather than an index.

In other words what you are trying to retrieve is already in $i. If you want
to access individual elements of the array by index you need to loop over an
index range, not the array values themselves.

For instance,

foreach (0 .. @$array) {
print $array->[$_];
}

Now the really cool thing is that you can remove (if you want) the temporary
array dereference and access the elements directly, say you want the first
element of the 'server1's log...

$servers->{'server1'}->[0];

Or the first 5 elements of each of the servers...

- Untested -
foreach my $servername (keys (%$servers)) {
my @first5lines = $servers->{$servername}->[0 .. 4];
}

There are any number of ways to access into the data structure directly.
Experience is about the only way to truly "get it" and once you do you won't
lose it again, and the doors will seemingly flood open to its uses, and of
course there is Perl OOP...

http://danconia.org

is this what you have in your code: "$$dbh->prepare($sql)"?

david

Are those line numbers actually in the file too? If so, that might cause
problems for you.

At this point, @in holds all the lines of the file...

.... but here, you only store the FIRST line (the first element of @in) in
the @col1 array.

Other people have suggested better approaches; I'm just pointing out the
flaw in your program.

--
Jeff "japhy" Pinyan [Email Removed] http://www.pobox.com/~japhy/
RPI Acacia brother #734 http://www.perlmonks.org/ http://www.cpan.org/
<stu> what does y/// stand for? <tenderpuss> why, yansliterate of course.
[ I'm looking for programming work. If you like my work, let me know. ]

Sorry about the mess there, Let me fix it:

$EXPORT_TAGS{':DEFAULT'} = $EXPORT_TAGS{':basic'};

Or

$EXPORT_TAGS{':DEFAULT'} .= $EXPORT_TAGS{':basic'};

Or

$EXPORT_TAGS{':DEFAULT'} = > ($EXPORT_TAGS{':basic'},@EXPORT);

There that's more readable!

Neither of these worked. I am beginning to think that there is something
wrong with ActivePerl and WinXP.

Try this. Make a sample text file named "testfile.txt" and put it in
directory "c:testdir"

then try this script...don't add anything like use File::glob and see if
it works:

my $test = ("c:\testdir\testfile.txt");
unlink glob ($test) || die "unlink failed: $!";

This simple little script does not delete testfile.txt from my machine. Why?

That looks like trouble. Using forward slashes, as Janek has
done below, would have been smarter.

That's not very good error-reporting. Maybe unlink failed
ninety-nine times and succeeded once...

Did they give any error messages?

And that's the wrong "or". If you use the alphabetical "or",
you'll at least get an error message.

unlink $test or die "unlink: $test: $!";

--
Steve

Probably this will work (haven't tried it):

$EXPORT_TAGS{':DEFAULT'} = [ @{$EXPORT_TAGS{':basic'}}, @EXPORT ];

But I would do this instead:

my @basic = qw(fred wilma barney dino);
our @EXPORT = (qw/foo bar baz/, @basic);
our %EXPORT_TAGS = (':basic' => @basic);

I don't think defining :DEFAULT for yourself is what the author of Exporter
had in mind...

Yes.

# init the hash key
$hash{four} = {} unless exists $hash{four};

# store access the internal hash by following the reference "->"
$hash{four}->{uid} = "uid4";
$hash{four}->{cn} = "cn4";
$hash{four}->{group} = "Group4";


Rob


-----Original Message-----
From: Tim Musson [mailto:[Email Removed]]
Sent: Friday, August 08, 2003 8:31 AM
To: [Email Removed]
Subject: Another reference question (hash of hash references)


beginners,

I am trying to build a hash of hash references. My problem is that I
need to be able to add a key/value pair to the internal hashes...

,----- [ Here is my test code (yes, I am working with LDAP) ]
#!perl
use strict;
use warnings;

my %hash = (
one => { uid => "uid1", cn => "cn1", group => "Group1" },
two => { uid => "uid2", cn => "cn2", group => "Group2" },
);
$hash{"three"} = { uid => "uid3", cn => "cn3", group => "Group3" };

$hash{"four"} = { uid => "uid4" };
$hash{"four"} = { cn => "cn4" };
$hash{"four"} = { group => "Group4" };

my $key;
foreach $key (sort keys %hash) {
my $iHash = $hash{$key};
print "
key: $key
hash-HRef: $hash{$key}
HRef: $iHash
hash/hash{uid}: $iHash->{uid}
hash/hash{cn}: $iHash->{cn}
hash/hash{group}: $iHash->{group}
";
}
`----- [ End of my test code ]

So, I add the keys "one" and "two" when I initialize the hash, then I
add "three" after. That works just fine, but I need to do something like
"four", and all I get in the output is "Group4" because the third time I
write the anon reference to the hash, it overwrites of course...

Any suggestions on how I can do this? I don't think I can really use an
array, and push to it because of how we plan to access the top level
hash.

Background, I am doing an LDAP query for a couple of attributes in one
DN, then another LDAP query in a different part of the LDAP tree for
some other attributes. The output for each query needs to be grouped by
something like UID (I will replace "one", "two", etc with the UID/CN
value as I extract it). Yes, it is a messed up LDAP structure, but I
can't do anything about that... :-(

Thanks for any help!

--
Tim Musson
Flying with The Bat! eMail v1.62q
Windows 2000 5.0.2195 (Service Pack 3)
Contrary to popular belief, Unix is user friendly. It just happens to be
selective about who it makes friends with


--
To unsubscribe, e-mail: [Email Removed]
For additional commands, e-mail: [Email Removed]

why thank you :)

well.. this is interesting- i am not sure how to interpret this line
properly. also, i assume that even split inodes will all get shoved through
the script... so, perhaps there is a way to concatonate/rename the split
inodes? or is there no way to see which belongs to which group?

well- this gives me a place to start looking. :)

no-> i wasn't all that sophisticated.. *shrug*

fantastic! i have never been terribly good with regexes and am trying to
avoid learning them again until perl6 *laugh* i must to too darn lazy!!

i agree- but something is nagging at the back of my head, telling me that it
was useful.... perhaps it is readable by another command... instead of using
mount... *sigh* i don't know :P

i'll try to rewrite it... see if i can get it to work again :)

_________________________________________________________________
MSN 8 helps eliminate e-mail viruses. Get 2 months FREE*.
http://join.msn.com/?page=features/virus

Well your Process id is $$, But I haven't any ideas on retieving the physical/virtual mem.

Hi William.

What you write depends on whether you want to /check/ the contents
of the data or simply extract the final word.

This program will extract the last complete word from any array of
strings, but won't check that the string started with

'The Wall will tell ME to update '

is this what you want?

HTH,

Rob



use strict;
use warnings;

my @array = (
'The Wall will tell ME to update AZID.',
'The Wall will tell ME to update IA.',
'The Wall will tell ME to update KSOK.',
'The Wall will tell ME to update MO.',
'The Wall will tell ME to update NVUT.',
'The Wall will tell ME to update OR.',
);

my @lastword = map /.*b(w+)/, @array;

print "$_n" foreach @lastword;

OUTPUT

AZID
IA
KSOK
MO
NVUT
OR

well, the undeletion howto is a little old (1999) but interesting to look
through...


http://tldp.org/HOWTO/Ext2fs-Undeletion.html#toc9

no! :) debugfs -f /filepath :) open opens the filesystem without
mounting it... then dump does its thing- all inside debugfs!!

and the mystery is solved!!!


now i would like to look into using this to make a perl script to automate
file recovery.... well, someday at anyrate!

willy

:)

interesting. without you providing much background information, purpose
(actually you did say you are trying to hook into @INC but i don't really
know what you mean by that), etc, i can only guess that you are trying to
build, compile and include some other modules when your users say "use Foo".
below is a toy program that hopefully will get you closer to what you need:

package Foo;

END{ unlink @ms }

our @ms;

sub new{
return bless {} => shift;
}

sub hi{
print "hin";
}

#--
#-- dynamicly build and include whatever modules the users requested
#--
sub import{

my $class = shift;

for(@_){

open(NM,">$_.pm") || die $!;

push(@ms, "$_.pm");

print NM qq/
package $_;
sub new{
return {} => shift;
}
sub $__say_hi{
print "$_ says hi\n";
}
1;
/;

close(NM);

require "$_.pm";
}
}

1;

__END__

a driver:

#!/usr/bin/perl -w
use strict;

#--
#-- Foo.pm builds Bar.pm and Ber.pm and Bee.pm and use it
#-- in fact, you can put as many module names here and Foo.pm will build it
for you
#--
use Foo qw(Bar Ber Bee);

my $f = Foo->new; $f->hi;

#--
#-- no need to 'use Bar' or 'use Ber' or 'use Bee' because Foo.pm does that
for us per request
#--
my $bar = Bar->new; $bar->Bar_say_hi;
my $ber = Ber->new; $ber->Ber_say_hi;
my $bee = Bee->new; $bee->Bee_say_hi;

__END__

prints:

hi
Bar says hi
Ber says hi
Bee says hi

in fact, if you look around, you wouldn't even find Bar.pm, Ber.pm or Bee.pm
anywhere because they only exist during your program runs and are deleted
automatically when your program ends. the user never know the existance of
them but are available for use when they need it! a pretty neat idea but
kind of dangerous (especially if you are downloading the modules from the
Net). you can use this technique (if you really want to do that and know
exactly what you are doing) to build arbitary complex class on the fly. the
idea is very simply though. again, without knowing what you are really
trying to accomplish, i can't recommand anything else.

david

interesting. without you providing much background information, purpose
(actually you did say you are trying to hook into @INC but i don't really
know what you mean by that), etc, i can only guess that you are trying to
build, compile and include some other modules when your users say "use Foo".
below is a toy program that hopefully will get you closer to what you need:

package Foo;

END{ unlink @ms }

our @ms;

sub new{
return bless {} => shift;
}

sub hi{
print "hin";
}

#--
#-- dynamicly build and include whatever modules the users requested
#--
sub import{

my $class = shift;

for(@_){

open(NM,">$_.pm") || die $!;

push(@ms, "$_.pm");

print NM qq/
package $_;
sub new{
return {} => shift;
}
sub $__say_hi{
print "$_ says hi\n";
}
1;
/;

close(NM);

require "$_.pm";
}
}

1;

__END__

a driver:

#!/usr/bin/perl -w
use strict;

#--
#-- Foo.pm builds Bar.pm and Ber.pm and Bee.pm and use it
#-- in fact, you can put as many module names here and Foo.pm will build it
for you
#--
use Foo qw(Bar Ber Bee);

my $f = Foo->new; $f->hi;

#--
#-- no need to 'use Bar' or 'use Ber' or 'use Bee' because Foo.pm does that
for us per request
#--
my $bar = Bar->new; $bar->Bar_say_hi;
my $ber = Ber->new; $ber->Ber_say_hi;
my $bee = Bee->new; $bee->Bee_say_hi;

__END__

prints:

hi
Bar says hi
Ber says hi
Bee says hi

in fact, if you look around, you wouldn't even find Bar.pm, Ber.pm or Bee.pm
anywhere because they only exist during your program runs and are deleted
automatically when your program ends. the user never know the existance of
them but are available for use when they need it! a pretty neat idea but
kind of dangerous (especially if you are downloading the modules from the
Net). you can use this technique (if you really want to do that and know
exactly what you are doing) to build arbitary complex class on the fly. the
idea is very simply though. again, without knowing what you are really
trying to accomplish, i can't recommand anything else.

david



--
To unsubscribe, e-mail: [Email Removed]
For additional commands, e-mail: [Email Removed]

__________________________________
Do you Yahoo!?
Yahoo! SiteBuilder - Free, easy-to-use web site design software
http://sitebuilder.yahoo.com

JWK> This is probably as close as you are going to get:

JWK> http://catb.org/~esr/jargon/

I like http://www.acronymfinder.com/

--
Tim Musson
Flying with The Bat! eMail v1.62q
Windows 2000 5.0.2195 (Service Pack 3)
Why is it that doctors call what they do "practice"?

You ought to be looking at the Proc::ProcessTable module.
I don't know about your NT requirement, but the following
is a sample that works well under linux.

#!/usr/bin/perl -w
use strict;
use Proc::ProcessTable;

my $t = new Proc::ProcessTable();

foreach my $p (@{$t->table}){
print $p->pid," ",$p->cmndline," ",$p->size,"n";
}
__END__

Just a suggestion, but could it be because unlink is taking the delete
"*.*" literally and expecting the file to contain a dot, whereas the shell
"knows" about DOS extensions and removes files without them?

Dave.

You're supposed to return a filehandle:

open my $fh, '<', ($response->content);
return $fh;

I'd also suggest caching the downloaded modules and letting
the constructor take a list of base urls.

And by the way, does anybody know offhand why the subroutine
name needs to be fully-qualified in the declaration? I haven't
really looked at this feature, but it seems like an strange
requirement.

--
Steve

Yes, it does. But it does not work when reading from a variable.

my $temp = '*997*';
print 'Deleted ' , unlink (<$temp>) , ' files.n';

This very simple variation of your example does not work.

The problem is that I have to read from a file and put the value from the
file into a variable. Although your "hard coded" example does work, it
doesn't work for a value read in from an external file and into a
variable. Any other ideas? I am all ears and out of ideas.

Yep. But i am using the temp files for doing that. And i would love to get rid of the temp files altogether.

open my $fh, '<', ($response->content);

Seems like we are opening a filehandle to a string. Very difficult to convince my sysadmin to get to 5.8 soon. Any other suggestions to get rid of those temp files. I hate them.

Give me a little of your magical sight -:)

Require says:

If the hook is an object, it must provide an INC method, that will be called as above, the first parameter being the object itself. (Note that you must fully qualify the sub's name, as it is always forced into package main.)


Thanx,
-Sharad

-----Original Message-----
From: Steve Grazzini [mailto:[Email Removed]]
Sent: Saturday, August 09, 2003 1:51 PM
To: Gupta, Sharad
Cc: [Email Removed]
Subject: Re: Ok I am tired


On Fri, Aug 08, 2003 at 10:49:39PM -0700, Gupta, Sharad wrote:

You're supposed to return a filehandle:

open my $fh, '<', ($response->content);
return $fh;

I'd also suggest caching the downloaded modules and letting
the constructor take a list of base urls.

And by the way, does anybody know offhand why the subroutine
name needs to be fully-qualified in the declaration? I haven't
really looked at this feature, but it seems like an strange
requirement.

--
Steve

IO::Stringy (non-core module) was the old way to do it...

It's not secure, but in a safe environment you could write
$res->content to some cache directory. Then before downloading
anything, just check the cache.

Yeah, that seems strange.

I suppose that *INC is "special", for the sake of %INC and
@INC... But I didn't expect it to force the subroutine
declaration into main:: as well.

--
Steve

the reason why YOUR version won't work is because when Perl sees '<$temp>',
it's trying to read from the file handle '*997*'. it's NOT doing glob for
you. example:

my $s = '*.pl';
my @c = ('*.pl');

#--
#-- even though the following 2 lines seems identical and should work to
give you
#-- all file names ending with *.pl in the current directory, only the
second version really works
#--
my @files1 = <$s>; #-- this does not work because Perl is trying to read
from the '*.pl' file handle!
my @files2 = <$c[0]>; #-- this does work. see reason below

for(@files1){
print "@files1: $_n";
}

for(@files2){
print "@files2: $_n"; #-- only this get print out.
}

to make the long story short: Perl consider $s to be a simple scalar (and
yes that's the official term) and whenever a simple scalar is put inside
'<>', Perl assumes it's a file handle that you are trying to read from.
otherwise, you can't even:

open(my $file,'some.txt') || die;
while(<$file>){ #-- doing glob or reading from $file?
#-- code
}
close($file);

it's reading from $file (the file handle) because $file is a considered to
be a simple scalar. now if you were to change your script to look like:

my $temp = '*997*';
print 'Deleted ' , unlink (<@{[$temp]}>) , ' files.n';

it will work because that tells Perl the stuff inside '<>' is not a file
handle so it should be handed to the glob function.

if you were really "all ears out", you should have tell us where all of your
files live and how (and where) you execute your script. i still think your
problem is largely related to Perl not able to find the files because you
are running the script from a different directory.

david

Hi Rob,

I am going to take issue with you on this one, on general principle. Oracle does not have
the best interests of Perl programmers in mind. There is really no good reason for someone
interested in Perl programmeing to settle for a default bundled version of Perl.

As a support technician, I frequently come across bundled versions of standard utilities that
are simply inadequate. Either they are outdated, or they only install the subset of
functionalities neded for that one program. Only as a last resort, for software that simply
cannot run without obsolete versions of such utilities, will I accede to the default install.

Much better to install each basic application discretely. Oracle is not among the standard
sources for a good Perl installation. It may be that some configuaration changes in Oracle
will be required in order to accomodate a antive Perl. Better to do that than to cripple
along on a quirky non-standard special-purpose Perl.

It is also possible that the Oracle installation is set to use its own Perl under any
circumstances. If not, and if it cannot accomodate the presence of a current full version of
Perl, then Oracle is broken and needs to be fixed.

Under any circumstances, I would recommend that a person starting into perl start out with
the current, and full version, from a Perl-oriented source.

Joseph

In

XML probably is your best bet assuming you are proficient in the use of
XSL.
I'll assume you're not when I say you'd do best using SGML, but then you
may
not be proficient in that either. Deprived of alternatives, learn the
basics of CSS. Page breaks do work in CSS, and there are many quick and
dirty tutorials online if you need it soon. So your documents will be HTML
and CSS, which isn't your very best bargain but which you can still work
with.

K.P.
_____________________________________________________





--
To unsubscribe, e-mail: [Email Removed]
For additional commands, e-mail: [Email Removed]



Just in case this is helpful to anyone:

HTML/CSS page breaks. This is the easiest way I've found to do this.

How to make a printer do a form feed using HTML, in order
to allow the browser app to do page-breaks.

If the following CSS exists:

<STYLE TYPE="text/css">
#break
{
page-break-AFTER: always;
}
</STYLE>


Then the following HTML will force a page break while printing:


<p ID='break'>



Shawn




**********************************************************************
This e-mail and any files transmitted with it may contain
confidential information and is intended solely for use by
the individual to whom it is addressed. If you received
this e-mail in error, please notify the sender, do not
disclose its contents to others and delete it from your
system.

**********************************************************************

$file_exists = $t->cmd("perl -e 'print 1 if (-s "file")'") or warn "Unable to execute command: $!n";
if ($file_exists) {
# do whatever
}

with my shell (/usr/bin/sh).

From the script under you are just replacing lines with a static
line/value.

<snip>

I don't see any reason to use hex.
There is a common idiom to use when searching for repetitions/uniqueness.
## untested example :)

@array = qw(one two one three four);

for (@array) {
if (defined($unique{$_}) {
s/$_/replacement/;
} else {
$unique{$_}++; ## $unique{$_} is now defined and true.
} ## and will be replaced if it comes up again

This works equally well for files, it's just a matter of s/@array/<FH>/
There *might* be a question of memory usage though, depending on
the size of the file your working with.

Also, sort -u would be faster and more efficient if you have large files,
but didn't need the replacement text.

Tor

You don't need the hex business (although it will work). Assuming your
long literal is in a variable $string, just:

s/Q$string/placey/gi;

will work (do you need /i?)

The problem appears to be that you are reading the file line by line,
but want to search and replace over multiple lines. If you set $/ to
undef, you can read the whole file into a single string and perform
the replacement that way.

How so?

$string = "Here is texttwithnnnewlines and tabstand spaces.n";

Either use the Text::CSV module from CPAN (or perhaps Text::CSV_XS), or
else use a regex like the following:

@fields = $str =~ m{ " [^"]* " | [^,]+ }xg;

If you also want to strip quotes, you can do:

@fields = map { s/^"// and s/"$// } $str =~ m{ ... }xg;

(Just fill the regex in.)

--
Jeff "japhy" Pinyan [Email Removed] http://www.pobox.com/~japhy/
RPI Acacia brother #734 http://www.perlmonks.org/ http://www.cpan.org/
<stu> what does y/// stand for? <tenderpuss> why, yansliterate of course.
[ I'm looking for programming work. If you like my work, let me know. ]

#are you using windows?
binmode FILE; #need binmode under windows
binmode TEMP;

I'm no security expert, but how can these be spoofed? They don't come from
the request headers, but are derived from the TCP connection itself.

Furthermore, how useful are these anyway? For example, I'm currently sitting
behind a NAT proxy along with 300 or so other folks, so you'll see the same
REMOTE_ADDR for any of us who visit your site. Or is that what you mean by
"spoof"?

OMG! don't assume that! :~)

:~)

Well, it can't be spoofed in the sense of being faked. If I'm connecting
from 206.107.121.3, There's no way to convince your server that I'm really
connecting from 66.118.101.132, AFAIK.

However, If I can use an intermediate system as a proxy, I can convince you
that I'm coming from a different host than I "actually" am.

No, if by "server" you mean the server on which you are looking at
REMOTE_ADDR. REMOTE_ADDR is the client address. You don't want to build any
scheme based on the supposed hardness of the client system.

But because of proxies, you may have a "good guy" and a "bad guy" using the
same proxy. So you can't use REMOTE_ADDR alone to distinguish between the
two for identification purposes.

If it matters, you need some way for the client to pass you some credentials
with the request that you can validate. You may even want to do this in
combination with REMOTE_ADDR, to decrease the risk that the credentials have
been compromised and are being used to attempt to gain access from an
unexpected host.