You've got me thinking about linear algebra, and I happened to doodle this up when I ought to have been doing work:

package QDMatrix;
use v5.36;
sub new($class, $n_minor, $values) {
    if (ref $values->[0]) {
        $#{$values->[$_]} == $n_minor or die "Irregular column len in 
+matrix: $#{$values->[$_]} != $n_minor"
            for 0..$#$values;
        $values= [ @$values ];
    } else {
        @$values % $n_minor == 0
            or die "Un-rectangular number of values in data: ".scalar(
+@$values)." / $n_minor = ".(@$values/$n_minor);
        $values= [
            map [ @{$values}[$_*$n_minor .. ($_+1)*$n_minor-1] ],
                0 .. int($#$values/$n_minor)
        ]
    }
    bless $values, $class;
}
sub flatten($self) {
    map @$_, @$self
}
sub clone($self) {
    bless [ map [ @$_ ], @$self ], ref $self;
}
sub dims($self) { scalar @$self, scalar @{$self->[0]} }
sub major($self, $i) { @{$self->[$i]} }
sub minor($self, $i) { map $_->[$i], @$self }
sub mul($self, $m2) {
    my ($maj, $min)= $self->dims;
    my ($m2_maj, $m2_min)= $m2->dims;
    $min == $m2_maj
        or die "Incompatible matrix sizes: ($maj,$min) X ($m2_maj,$m2_
+min)";
    my @ret;
    for my $i (0 .. $maj-1) {
        for my $j (0 .. $m2_min-1) {
            my $sum= 0;
            $sum += $self->[$i][$_] * $m2->[$_][$j] for 0 .. $min-1;
            $ret[$i][$j]= $sum;
        }
    }
    bless \@ret, ref $self;
}
sub transpose($self) {
    bless [ map [ $self->minor($_) ], 0 .. $#{$self->[0]} ], ref $self
+;
}


my $identity= QDMatrix->new(3, [ 1,0,0, 0,1,0, 0,0,1 ]);
my $x= QDMatrix->new(3, [ 4,5,1 ])->mul($identity->mul(QDMatrix->new(3
+, [ 1,0,0, 0,1,0, 2,0,1 ])));
use DDP; p $x;
[download]

That's very neat! If you have any tests/examples, would you be willing to put them here? I'd like to put the above in a PDL tutorial section, together with the PDL equivalents. It won't surprise you that those would probably be very concise, but I don't want to spend 5 minutes producing a somewhat unreliable and partly-incorrect version, when with tests that show inputs and outputs I could spend 6 minutes making a sufficiently-correct version :-)

That would even help those who don't know PDL but might be a little interested in some simple idioms!

No tests, since I was just fiddling, but this mini meditation did eventually evolve into a CPAN module !

You might find t/04-transform.t to be what you're looking for.

Could you put together a unit test? Like maybe run through it once with Python and log the interesting variables at each line and then I can work toward making the perl generate the same values and not need to consult too many implementation details of Python?

As shown elsewhere, I remain a bit of a noob at linear algebra (LA) myself. This includes IndexedFaceSet to 3D lines in two lines of PDL and the follow-on work in updating PDL's 3d demo, for which I needed to actually learn some LA. One really helpful resource for this was the YouTube channel 3blue1brown, and in particular his linear algebra series which visualises the geometric stuff that underpins LA: https://www.youtube.com/playlist?list=PLZHQObOWTQDPD3MizzM2xVFitgF8hE_ab.