{
    open(my $fh, "somefile.txt") or die("ack - $!");
    sub readfile {
        return <$fh>;
    }
}
print while readfile();
[download]

_________
broquaint

You didn't create a closure, but an anonymous subroutine. I'll try to explain in the most simple way what a closure is.

A classical example of a simple closure is that of the "multiplier generator":

sub multiplier_by {
  my $x = shift ;

  return sub {
    my $n = shift ;
    return $n * $x ;
  }
}
[download]

Then if you run this:

my $m2 = multiplier_by(2) ;
my $m3 = multiplier_by(3) ;
[download]

you will have:

my $i = 5 ;
print $m2->($i) ; # prints 10
print $m3->($i) ; # prints 15

# other syntaxes for $m2, $m3 invokations allowed :-)
[download]

Now follow the execution of my $m2 = multiplier_by(2) ;: you pass a value of 2, that goes into the lexical $x and gets used in the "anonymous subroutine" definition. When the subroutine returns, you assign the return value to $m2, and here the magic happens: since you are still using it, $x is still alive somewhere in your RAM, and is accessible only inside the code inside $m2. You closed it in a cage, poor $x :-). And you have a reference to a subroutine that multiplies its argument by 2. That's your closure: ta-dah!

When you call again multiplier_by passing 3 as argument, things still work because the newly created $x has nothing in common with the previous one. So $m3 gets a reference to a subroutine that multiplies by 3 the parameter you pass to it.

I hope I made things clearer and not confused you more :-)

A note on your code: since you are declaring the variables in your subroutine with my, which is a really-good-thing-to-do, the subsequent chain of $var = 0 unless $var is superfluous as it will be always executed. You could assign a value of 0 directly in the declaration: my $var = 0 ;

Phew! I think it's better for me to stop here or my boss will fire me!

Ciao!
--bronto

# Another Perl edition of a song:
# The End, by The Beatles
END {
  $you->take($love) eq $you->made($love) ;
}

-- Randal L. Schwartz, Perl hacker

Well, yes. From what I saw it looks like you have to have the whold @data array to pass it. As I said, I'm doing mine on a per line basis. Also the computer this is going to be on has a version of WinZip which for some reason isn't extracting the tar files on CPAN correctly (at all), so I'm trying to keep the modules I'm using to a minimum (plus: is it that complicated of code that I need to use a module to simpilfy it?)

I don't need detailed statistical output of the data I'm going through (the person I'm making this for has something for this already--I'm just getting, through this and other scripts I've written, more data points to try and spot outliers, and for a few other purposes he defined).

my $bf_1;
{ # Start a new block to avoid cluttering the environment
    my $sum_x = 0;
    $bf_1 = sub {
        # This block references $sum_x,
        # so it will be captured in the closure
        my ($operation, @args) = @_;
        # You didn't mean @ARGV; it's for command-line args
        if($operation eq 'Add') {
            $sum_x += $args[0];
        }
    };
}
[download]

And finally, you might want to proofread your calculations for $sum_x2 and $sum_xy. :-)

I have to confess that I don't understand why you need closures at all. It appears that you are intending to use them to keep the running tallies, but you could just as easily do that with an array or hash-table. Also, there's no reason to be using eval when calculating the final values.

--rjray

For starters, I think you switched a and b in the equations you give. The correct equations are: given here and here,. These equations are taken from an article on mathworld.wolfram.com on Least Squares Fitting. Notice these equations are implicit definitions of a and b. In other words both equations have both variables, so you can't simply plug in values to these equations and get a and b.

Simplifying these equations is not difficult but not trivial. The details of simplification is covered in the article. The resulting equations are the equations you need to use to solve for the coefficients of the linear least squares fit, a and b. The formulas you use try to solve for a using b, and solve for b using a. You can't do that, in perl not even using eval. This, however; is all math, and a bit off topic for Perlmonks. So let's talk Perl.

For this task a closure is a bit over kill as stated above. Even arrays and hash tables are excessive unless you are trying to calculate fits on several sets of data at once. In the simple case plain old variables work just fine.

The following example uses the first two columns of the input as x and y and calculates a and b of the least squares fit.

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

my $sum_x = 0;
my $sum_y = 0;
my $sum_x2 = 0;
my $sum_xy = 0;
my $n = 0;


while( <> ) {
    my ( $x, $y ) = split;
    
    $sum_x += $x;
    $sum_y += $y;
    $sum_x2 += $x * $x;
    $sum_xy += $x * $y;
    $n++;
    
}

my $a = ( $sum_y * $sum_x2 - $sum_x * $sum_xy ) /
              ( $n * $sum_x2 - $sum_x * $sum_x );  
my $b =     ( $n * $sum_xy - $sum_x * $sum_y ) /
              ( $n * $sum_x2 - $sum_x * $sum_x );  

print "a = $a; b = $b\n";
[download]

This code prints out

	a = 0.999999714285714; b = 2.00000057142857

when given the following input

-2 -3
-1 -1
 0  0.99999
 1  3.00001
 2  5
 3  7

which is veritably correct.

This would be reinventing the wheel as pointed out by merlyn above for a small data set like the example. However, this implementation does not require storing the entire data set in memory. So it might be useful if the data set is large. There are other problems if the data set gets to large. The sum of the x squared's or the sum of the x*y's may get too large if the data set is really big. So, you may get an overflow, or some loss of precision in the calculation with large data sets. So don't blindly trust the outputs if the data set is large. Determining how valid the fit is is off topic for Perlmonks (and a bit over my head), but there are some resources listed in the article above, and around the internet.

update: I cleaned up some spelling, and completely changed my position here.

After writing this response I realized that you might be trying to calculate the least squares fit for multiple data sets at the same time. If you are, then the advice I gave isn't very useful. It turns out that closures might not be such a bad idea after all. Here is my attempt to solve the problem using closures.

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

# Create an array of closures
my @LS_closures = ( 
        create_LS_closure(),
        create_LS_closure(),
    );

while( <> ) {
    my ( $x1, $y1, $x2, $y2 ) = split;
    
    # add the current data to the closure
    $LS_closures[0]{add}->( $x1, $y1 );
    $LS_closures[1]{add}->( $x2, $y2 );
    
}

# calculate the least squares coefficient
my ( $a, $b ) = $LS_closures[0]{calcCoefs}->();
print "for the first set of data a = $a; b = $b\n";

( $a, $b ) = $LS_closures[1]{calcCoefs}->();
print "for the second set of data a = $a; b = $b\n";

# -----------------------------------------------
# The closure generating subroutine
sub create_LS_closure {

    # these variable are unique to each closure 
    # created
    my $sum_x = 0;
    my $sum_y = 0;
    my $sum_x2 = 0;
    my $sum_xy = 0;
    my $n = 0;
    
    return { 

        # This is the anonymous function for adding
        # data a to the least squares fit
        add => sub {
            my ($x, $y) = @_;
        
            $sum_x += $x;
            $sum_y += $y;
            $sum_x2 += $x * $x;
            $sum_xy += $x * $y;
            $n++;
        },
        
        # This is the anonymous function for
        # computing the coefficients of the
        # least squares fit
        calcCoefs => sub {
            my $a = ( $sum_y * $sum_x2 - $sum_x * $sum_xy ) /
                          ( $n * $sum_x2 - $sum_x * $sum_x );  
            my $b =     ( $n * $sum_xy - $sum_x * $sum_y ) /
                          ( $n * $sum_x2 - $sum_x * $sum_x );  
            return ($a, $b);
        }
    }
}
[download]

When given the following input

-2 -3 -2  3
-1 -1 -1  1
 0  1  0 -1
 1  3  1 -3
 2  5  2 -5
 3  7  3 -7

for the first set of data a = 1; b = 2
for the second set of data a = -1; b = -2

The calling code appears to be quite flexible, and the closure could probably be moved to a module. So it appears that using closures to calculate least squares fits might not be such a bad idea!

Comments? Questions?

enjoy

meta4