It looks like I misunderstood the Stackoverflow question “Create vectors with differents lenghts in perl [sic]”. The OP is satisfied with the answer he received, but I like the question I thought he was asking more than the one he actually was asking.

So, let’s say I want to generate a matrix of random entries whose column vectors have random length.

First things first. Presumably, one would be using this code for some kind of simulation or analysis where the statistical properties of the pseudo-RNG generator matter. In such cases, it is better to start with a pRNG with known good properties rather than rely on whatever Perl’s builtin `rand`

got linked to. I give a really extreme example of inadequacy elsewhere on this blog, but even if your builtin `rand`

doesn’t generate such few values, you can’t rule out things like higher order correlations without actually running a battery of tests. Therefore, I am going use a Perl implementation of Mersenne twister.

In a serious simulation exercise, you should seed a `Math::Random::MT`

object with a vector of random integers. On a *nix system, `/dev/random`

and on a Windows system CryptGenRandom (assuming XP SP3 or later) will probably be good enough for this purpose, so I am going to omit that part from the code below.

In a vain attempt to channel my inner MJD, I first wrote a random vector generator generator, creatively named `genvgen`

:

```
sub genvgen {
my ($terminator, $randmax) = @_;
return sub {
my $is_terminated = $terminator->();
my $gen = Math::Random::MT->new( ... );
return sub {
$is_terminated and return;
$is_terminated = $terminator->();
return $gen->rand($randmax);
}
}->();
}
```

The first argument, `$terminator`

is a coderef that returns true if sequence generation should be terminated. For example, if you want sequences to terminate with probability 10%, you’d write:

```
my $t = Math::Random::MT->new( ... );
my $v = genvgen(sub { $t->rand < 0.1 }, 10);
for my $i (1 .. 20) {
next unless defined(my $x = $v->());
printf "%d: %g\n", $i, $x;
}
```

Given that, generating the matrix is just an application of map:

```
sub run {
my %args = (
cols => 5,
prob => 0.3,
randmax => 10,
@_,
);
my $terminator = Math::Random::MT->new;
my @matrix = map genvgen(
sub { $terminator->rand < $args{prob} },
$args{randmax},
), 1 .. $args{cols};
# print 10 rows
for (1 .. 10) {
my @row = map {
my $x = $_->();
defined($x) ? int($x) : ' ';
} @matrix;
say join('|', @row);
}
return;
}
```

Note that if want to make sure each column contains at least one element, then change `genvgen`

to:

```
sub genvgen {
my ($terminator, $randmax) = @_;
return sub {
my $is_terminated;
my $gen = Math::Random::MT->new( ... );
return sub {
$is_terminated and return;
$is_terminated = $terminator->();
return $gen->rand($randmax);
}
}->();
}
```