# ETOOBUSY đźš€ minimal blogging for the impatient

# PWC145 - Dot Product

**TL;DR**

Here we are with TASK #1 from The Weekly Challenge #145. Enjoy!

# The challenge

You are given 2 arrays of same size,

`@a`

and`@b`

.Write a script to implement

`Dot Product`

.

Example:`@a = (1, 2, 3); @b = (4, 5, 6); $dot_product = (1 * 4) + (2 * 5) + (3 * 6) => 4 + 10 + 18 => 32`

# The questions

My assumption here is that we are talking about the Dot Product:

In mathematics, the dot product or scalar product is an algebraic operation that takes two equal-length sequences of numbers (usually coordinate vectors), and returns a single number. [â€¦] The name â€śdot productâ€ť is derived from the centered dot

`Â·`

, that is often used to designate this operation [â€¦]

Which implies:

- the two input vectors are from the same vector space or, at least, the two sequences of numbers take elements from the same field;
- the product itself can be defined as follows:

# The solution

Raku first, which allows for a very compact solution. We define a
`class`

for storing vectors, and overload/define an operator `Â·`

to
implement the Dot Product:

```
#!/usr/bin/env raku
use v6;
class Vector { has @.v; method new (*@x) { self.bless(v => @x) } }
sub infix:<Â·> (Vector:D $x, Vector:D $y) { ($x.v Â»*Â« $y.v).sum }
sub MAIN {
my $a = Vector.new(1, 2, 3);
my $b = Vector.new(4, 5, 6);
put $a Â· $b;
}
```

Weâ€™re using the `Â»*Â«`

version here to insist that the two sequences of
numbers at both ends have the same number of elements. In case they
donâ€™tâ€¦ it will complain loudly.

The translation into Perl is moreâ€¦ *lower level*, but still we can
overload something to represent the operation:

```
#!/usr/bin/env perl
use v5.24;
use warnings;
use experimental 'signatures';
no warnings 'experimental::signatures';
my $v = Vector->new(1, 2, 3);
my $w = Vector->new(4, 5, 6);
say $v . $w;
package Vector;
use v5.24;
use experimental 'signatures';
no warnings 'experimental::signatures';
use overload
'.' => sub ($v, $w, @rest) {
die "size mismatch\n" unless $v->$#* == $w->$#*;
my $dp = 0;
$dp += $v->[$_] * $w->[$_] for 0 .. $v->$#*;
return $dp;
};
sub new ($package, @a) { bless \@a, $package }
```

In this case we have to explicitly check for matching sizes of the
underlying arrays and possibly `die`

if they are not the same.

Stay safe and mathy, people!

*Comments? Octodon, Twitter, GitHub, Reddit, or drop me a line!*