With sparse binary patterns it's quite apparent. For example, let's multiply 00100010001001001 by 111. Sounds hard? It's actually easy, you replace each 001 in the long pattern with the short pattern and end up with 11101110111111111. In the same way you can copy a byte to different places in a word. This may sometimes be faster and/or less bother than bit-shifting:

int64 fillInt64WithByte_shift(int8 b) {

return b << 56 | b << 48 | b << 40 | b << 32 | b << 24 | b << 16 | b << 8 | b;

}

vs.

int64 fillInt64WithByte_mul(int8 b) {

return 0x0101010101010101 * b;

}

It also works with decimal numbers: 10101 x 99 is 999999. If you have a number that's not a 1 in the target pattern, you need to multiply your source pattern with that: 001 002 003 0005 x 203 = 203 406 609 1015.

However, the simple copy splatting only works when you don't have overlaps. With overlaps you need to add the new splat to the target pattern. Let's consider non-carry addition first using 1001301001 x 211 as the example. First you fill in the non-overlapping parts (the 1001001001 pattern) and end up with 211 211 211 211. To integrate the 3 into the result you multiply it by 211 and add the result to the target pattern.

1001301001 x 211 =

211211211211

+ 633

------------

211274511211

When you have carries, it gets a good deal more tedious. Consider binary 1111 x 1111. First we splat 1111 on the first 1 in the target pattern: 01111000, then on the second 1: 00111100, etc. and finally get 01111000 + 00111100 + 00011110 + 00001111 = 11100001. Drudgery.

We could move it to base-15 and get 10 x 10 = 100, then convert that back to base-2... for no benefit whatsoever. 1111^2 x 1 = 1111 x 1111. Or do a trick with 10000 x 1111 - 1111 = 11110000 - 1111 = 11100001.

Or convert to base-16 for F x F = E1, then convert that to base-2 for 1110 0001. Note the similarity between F x F = E1, 9 x 9 = 81, o7 x o7 = o61, b1 x b1 = b01. This can be explained by

For base N, N = 10 - 1:

N x N = N x (10 - 1)

= N x 10 - N

= N x 10 - (10 - 1)

= (N x 10 - 10) + 1

= (N-1) x 10 + 1

Back to splat-additive multiplication, it seems to work for positive integers. Does it work for negative ones? Well, yes, 1001001 * -101 = -101000000 + -101000 + -101 = -101101101. And there's that sign-trick to turn multiplication of negative integers to multiplication of positive integers: -A x B = -(A x B), -A x -B = -(-(AxB)) = AxB.

Does it work for matrices... not that I can tell. Matrix multiplication is not splatting anyhow. What would a splat-additive matrix multiplication operation look like? I don't know, let's start exploring by trying to extend the scalar splat-additive multiplication to vectors. If we treat vectors as bucket-based integers (that is, no carries, base-∞), integer-like splat-additive vector multiplication would be quite easy. For example,

`[1 0 0 2] [x] [3 6] = [3 6 0 6 12]`

, but what can that be used for? Is there some sensible conversion to scalar from it? Can it be extended to matrices?As an aside, scalar vector multiplication can be used to make integer multiplication a bit simpler. Using 32 x 1935 as an example:

`32 x [1 9 3 5] = [32 288 96 160]`

. We can convert that to an integer value by doing a base conversion for each element and adding them together: 32*1000 + 288*100 + 96*10 + 160*1 = 61920 = 32 x 1935.Another way to do splat multiplication with vectors would be to generate a matrix from vector multiplication, an approach not entirely without appeal.

`[A B] x [C D]`

would result in `[ [AC AD] [BC BD] ]`

. It can express number multiplication as a special case: AxB would be |A| x |B| = AxB (I'm using |A| to say that |A| is a single-element vector of zero dimension). If you have dimensional numbers, it preserves the dimensionality of the result, `[Length] x [Width] = [[Area]]`

. Can the vector-splatting multiplication be extended to vectors of vectors? Seems so:

[ [1 2] [3] ] x [ [5 5] [6 2] ] would be, uh, ...

[ [ [1 2]x[5 5] [1 2]x[6 2] ] [ [3]x[5 5] [3]x[6 2] ] ] =

[ [ [[5 5] [10 10]] [[6 2] [12 4]] ] [ [[15] [15]] [[18] [6]] ] ]

And to continue with the dimensional numbers,

[Height] x [[Area]] = [[[ Height x Area ]]]

[[Area]] x [[Area]] = [[[[ Hypercube! ]]]]

What properties would this vector-splat multiplication have?

[ A B ] x [ C D ] = [ [AC AD] [BC BD] ]

[ C D ] x [ A B ] = [ [CA CB] [DA DB] ]

Not commutative (unless the equality is sum-equality: A = B if sum(A) = sum(B).)

([ A B ] x [ C D ]) x [ E F ] =

[ [AC AD] [BC BD] ] x [ E F ] =

[ [[ACE ACF] [ADE ADF]] [[BCE BCF] [BDE BDF]] ]

[ A B ] x ([ C D ] x [ E F ]) =

[ A B ] x [ [CE CF] [DE DF] ] =

[ [[ACE ACF] [ADE ADF]] [[BCE BCF] [BDE BDF]] ]

Seems to be associative.

The identity element would be a dimensionless 1:

1 x [ A B ] = [ 1xA 1xB ] = [ A B ]

Note that a dimensional one won't do:

[1] x [ A B ] = [ [A] [B] ]

To do the inverse element, we need vectors with negative dimensions:

I x [ A B ] = 1 requires I to reduce the dimension of [ A B ]

Additionally, the inverse element requires sum-equality (i.e. [A B] = [B A])

[A B] = [C] iff A + B = C

|0.5 0.5| = 0.5 + 0.5 = 1, hello confusing notation for dimensionless vectors

[[A [B] C]] = |[[[B]]] [[A C]]|, hello polynomial notation

I x [ A B ] = 1

[1/2A 1/2B]^{-1}x [ A B ] = |A/2A B/2B| = |1/2 1/2| = 1

So the inverse function would be

-- get inverse vector for which V x inv(V) = 1

inv(V) = (map (\i -> 1/(V_len*i)) V)^{-V_dim}

...ghhh. So, uh, I guess with sum-equality it could maybe form a field with some sort of vector addition. The real question is whether there is anything where this multidimensional splat-multiplication works better than existing methods. It looks a lot like polynomials. Maybe the vector addition could be..

|A B| = (A + B)_{0}

[A B] = (A + B)_{1}

|[[A B] C] D| = |[[A B]] [C] D| = (A+B)_{2}+ C_{1}+ D_{0}

= [[A B]] + [C] + |D|

That's kinda interesting, the (A+B)

_{2}isn't (A+B)

^{2}but rather means that (A+B) is a two-dimensional number.

Oh well, back to the grind.