5 added 12 characters in body

# MATL, 19 bytes

PiYdt"TF2&YStpsw]xx


Try it online!

### Explanation

This builds a block-diagonal matrix with the two inputs, reversing the first. For example, with inputs [1 4 3 5], [1 3 2] the matrix is

[ 5 3 4 1 0 0 0
0 0 0 0 1 3 2 ]


Each entry of the convolution is obtained by shifting the first row one position to the right, computing the product of each column, and summing all results.

In principle, the shifting should be done padding with zeros from the left. Equivalently, circular shifting can be used, because the matrix contains zeros at the appropriate entries.

For example, the first result is obtained from the shifted matrix

[ 0 5 3 4 1 0 0
0 0 0 0 1 3 2 ]


and is thus 1*1 == 1. The second is obtained from

[ 0 0 5 3 4 1 0
0 0 0 0 1 3 2 ]


and is thus 4*1+1*3 == 7, etc. This must be done m+n-1 times, where m and n are the input lengths. The code uses a loop with m+n iterations (which saves some bytes) and discards the last result.

P          % Take first input (numeric vactor) implicitly and reverse it
i          % Take second input (numeric vactor)
Yd         % Build diagonal matrix with the two vectors
t          % Duplicate
"          % For each column of the matrix
TF2&YS   %   Circularly shift first row 1 step to the right
t        %   Duplicate
p        %   Product of each column
s        %   Sum all resultsthose products
w        %   Swap top two elements in stack. The shifted matrix is left on top
]          % End for
xx         % Delete matrix and last result. Implicitly display


# MATL, 19 bytes

PiYdt"TF2&YStpsw]xx


Try it online!

### Explanation

This builds a block-diagonal matrix with the two inputs, reversing the first. For example, with inputs [1 4 3 5], [1 3 2] the matrix is

[ 5 3 4 1 0 0 0
0 0 0 0 1 3 2 ]


Each entry of the convolution is obtained by shifting the first row one position to the right, computing the product of each column, and summing all results.

In principle, the shifting should be done padding with zeros from the left. Equivalently, circular shifting can be used, because the matrix contains zeros at the appropriate entries.

For example, the first result is obtained from the shifted matrix

[ 0 5 3 4 1 0 0
0 0 0 0 1 3 2 ]


and is thus 1*1 == 1. The second is obtained from

[ 0 0 5 3 4 1 0
0 0 0 0 1 3 2 ]


and is thus 4*1+1*3 == 7, etc. This must be done m+n-1 times, where m and n are the input lengths. The code uses a loop with m+n iterations (which saves some bytes) and discards the last result.

P         % Take first input (numeric vactor) implicitly and reverse it
i         % Take second input (numeric vactor)
Yd        % Build diagonal matrix with the two vectors
t         % Duplicate
"         % For each column of the matrix
TF2&YS  %   Circularly shift first row 1 step to the right
t       %   Duplicate
p       %   Product of each column
s       %   Sum all results
w       %   Swap top two elements in stack. The shifted matrix is left on top
]         % End for
xx        % Delete matrix and last result. Implicitly display


# MATL, 19 bytes

PiYdt"TF2&YStpsw]xx


Try it online!

### Explanation

This builds a block-diagonal matrix with the two inputs, reversing the first. For example, with inputs [1 4 3 5], [1 3 2] the matrix is

[ 5 3 4 1 0 0 0
0 0 0 0 1 3 2 ]


Each entry of the convolution is obtained by shifting the first row one position to the right, computing the product of each column, and summing all results.

In principle, the shifting should be done padding with zeros from the left. Equivalently, circular shifting can be used, because the matrix contains zeros at the appropriate entries.

For example, the first result is obtained from the shifted matrix

[ 0 5 3 4 1 0 0
0 0 0 0 1 3 2 ]


and is thus 1*1 == 1. The second is obtained from

[ 0 0 5 3 4 1 0
0 0 0 0 1 3 2 ]


and is thus 4*1+1*3 == 7, etc. This must be done m+n-1 times, where m and n are the input lengths. The code uses a loop with m+n iterations (which saves some bytes) and discards the last result.

P          % Take first input (numeric vactor) implicitly and reverse it
i          % Take second input (numeric vactor)
Yd         % Build diagonal matrix with the two vectors
t          % Duplicate
"          % For each column of the matrix
TF2&YS   %   Circularly shift first row 1 step to the right
t        %   Duplicate
p        %   Product of each column
s        %   Sum all those products
w        %   Swap top two elements in stack. The shifted matrix is left on top
]          % End for
xx         % Delete matrix and last result. Implicitly display

4 deleted 100 characters in body

# MATL, 19 bytes

PiYdt"TF2&YStpsw]xx


Try it online!

This errors when one of the inputs is empty (but produces the correct output, which is nothing).

### Explanation

This builds a block-diagonal matrix with the two inputs, reversing the first. For example, with inputs [1 4 3 5], [1 3 2] the matrix is

[ 5 3 4 1 0 0 0
0 0 0 0 1 3 2 ]


Each entry of the convolution is obtained by shifting the first row one position to the right, computing the product of each column, and summing all results.

In principle, the shifting should be done padding with zeros from the left. Equivalently, circular shifting can be used, because the matrix contains zeros at the appropriate entries.

For example, the first result is obtained from the shifted matrix

[ 0 5 3 4 1 0 0
0 0 0 0 1 3 2 ]


and is thus 1*1 == 1. The second is obtained from

[ 0 0 5 3 4 1 0
0 0 0 0 1 3 2 ]


and is thus 4*1+1*3 == 7, etc. This must be done m+n+1m+n-1 times, where m and n are the input lengths. The code uses a loop with m+n iterations (which saves some bytes) and discards the last result.

P         % Take first input (numeric vactor) implicitly and reverse it
i         % Take second input (numeric vactor)
Yd        % Build diagonal matrix with the two vectors
t         % Duplicate
"         % For each column of the matrix
TF2&YS  %   Circularly shift first row 1 step to the right
t       %   Duplicate
p       %   Product of each column
s       %   Sum all results
w       %   Swap top two elements in stack. The shifted matrix is left on top
]         % End for
xx        % Delete matrix and last result. Implicitly display


# MATL, 19 bytes

PiYdt"TF2&YStpsw]xx


Try it online!

This errors when one of the inputs is empty (but produces the correct output, which is nothing).

### Explanation

This builds a block-diagonal matrix with the two inputs, reversing the first. For example, with inputs [1 4 3 5], [1 3 2] the matrix is

[ 5 3 4 1 0 0 0
0 0 0 0 1 3 2 ]


Each entry of the convolution is obtained by shifting the first row one position to the right, computing the product of each column, and summing all results.

In principle, the shifting should be done padding with zeros from the left. Equivalently, circular shifting can be used, because the matrix contains zeros at the appropriate entries.

For example, the first result is obtained from the shifted matrix

[ 0 5 3 4 1 0 0
0 0 0 0 1 3 2 ]


and is thus 1*1 == 1. The second is obtained from

[ 0 0 5 3 4 1 0
0 0 0 0 1 3 2 ]


and is thus 4*1+1*3 == 7, etc. This must be done m+n+1 times, where m and n are the input lengths. The code uses a loop with m+n iterations (which saves some bytes) and discards the last result.

P         % Take first input (numeric vactor) implicitly and reverse it
i         % Take second input (numeric vactor)
Yd        % Build diagonal matrix with the two vectors
t         % Duplicate
"         % For each column of the matrix
TF2&YS  %   Circularly shift first row 1 step to the right
t       %   Duplicate
p       %   Product of each column
s       %   Sum all results
w       %   Swap top two elements in stack. The shifted matrix is left on top
]         % End for
xx        % Delete matrix and last result. Implicitly display


# MATL, 19 bytes

PiYdt"TF2&YStpsw]xx


Try it online!

### Explanation

This builds a block-diagonal matrix with the two inputs, reversing the first. For example, with inputs [1 4 3 5], [1 3 2] the matrix is

[ 5 3 4 1 0 0 0
0 0 0 0 1 3 2 ]


Each entry of the convolution is obtained by shifting the first row one position to the right, computing the product of each column, and summing all results.

In principle, the shifting should be done padding with zeros from the left. Equivalently, circular shifting can be used, because the matrix contains zeros at the appropriate entries.

For example, the first result is obtained from the shifted matrix

[ 0 5 3 4 1 0 0
0 0 0 0 1 3 2 ]


and is thus 1*1 == 1. The second is obtained from

[ 0 0 5 3 4 1 0
0 0 0 0 1 3 2 ]


and is thus 4*1+1*3 == 7, etc. This must be done m+n-1 times, where m and n are the input lengths. The code uses a loop with m+n iterations (which saves some bytes) and discards the last result.

P         % Take first input (numeric vactor) implicitly and reverse it
i         % Take second input (numeric vactor)
Yd        % Build diagonal matrix with the two vectors
t         % Duplicate
"         % For each column of the matrix
TF2&YS  %   Circularly shift first row 1 step to the right
t       %   Duplicate
p       %   Product of each column
s       %   Sum all results
w       %   Swap top two elements in stack. The shifted matrix is left on top
]         % End for
xx        % Delete matrix and last result. Implicitly display

3 deleted 1 character in body

# MATL, 19 bytes

PiYdt"TF2&YStpsw]xx


Try it online!

This errors when one of the inputs is empty (but produces the correct output, which is nothing).

### Explanation

This builds a block-diagonal matrix with the two inputs, reversing the first. For example, with inputs [1 4 3 5], [1 3 2] the matrix is

[ 5 3 4 1 0 0 0
0 0 0 0 1 3 2 ]


Each entry of the convolution is obtained by shifting the first row one position to the right, computing the product of each column, and summing all results.

In principle, the shifting should be done padding with zeros from the rightleft. Equivalently, circular shifting can be used, because the matrix contains zeros at the appropriate entries.

For example, the first result is obtained from the shifted matrix

[ 0 5 3 4 1 0 0
0 0 0 0 1 3 2 ]


and is thus 1*1 == 1. The second is obtained from

[ 0 0 5 3 4 1 0
0 0 0 0 1 3 2 ]


and is thus 4*1+1*3 == 7, etc. This must be done m+n+1 times, where m and n are the input lengths. The code uses a loop with m+n iterations (which saves some bytes) and discards the last result.

P         % Take first input (numeric vactor) implicitly and reverse it
i         % Take second input (numeric vactor)
Yd        % Build diagonal matrix with the two vectors
t         % Duplicate
"         % For each column of the matrix
TF2&YS  %   Circularly shift first row 1 step to the right
t       %   Duplicate
p       %   Product of each column
s       %   Sum all results
w       %   Swap top two elements in stack. The shifted matrix is left on top
]         % End for
xx        % Delete matrix and last result. Implicitly display


# MATL, 19 bytes

PiYdt"TF2&YStpsw]xx


Try it online!

This errors when one of the inputs is empty (but produces the correct output, which is nothing).

### Explanation

This builds a block-diagonal matrix with the two inputs, reversing the first. For example, with inputs [1 4 3 5], [1 3 2] the matrix is

[ 5 3 4 1 0 0 0
0 0 0 0 1 3 2 ]


Each entry of the convolution is obtained by shifting the first row one position to the right, computing the product of each column, and summing all results.

In principle, the shifting should be done padding with zeros from the right. Equivalently, circular shifting can be used, because the matrix contains zeros at the appropriate entries.

For example, the first result is obtained from the shifted matrix

[ 0 5 3 4 1 0 0
0 0 0 0 1 3 2 ]


and is thus 1*1 == 1. The second is obtained from

[ 0 0 5 3 4 1 0
0 0 0 0 1 3 2 ]


and is thus 4*1+1*3 == 7, etc. This must be done m+n+1 times, where m and n are the input lengths. The code uses a loop with m+n iterations (which saves some bytes) and discards the last result.

P         % Take first input (numeric vactor) implicitly and reverse it
i         % Take second input (numeric vactor)
Yd        % Build diagonal matrix with the two vectors
t         % Duplicate
"         % For each column of the matrix
TF2&YS  %   Circularly shift first row 1 step to the right
t       %   Duplicate
p       %   Product of each column
s       %   Sum all results
w       %   Swap top two elements in stack. The shifted matrix is left on top
]         % End for
xx        % Delete matrix and last result. Implicitly display


# MATL, 19 bytes

PiYdt"TF2&YStpsw]xx


Try it online!

This errors when one of the inputs is empty (but produces the correct output, which is nothing).

### Explanation

This builds a block-diagonal matrix with the two inputs, reversing the first. For example, with inputs [1 4 3 5], [1 3 2] the matrix is

[ 5 3 4 1 0 0 0
0 0 0 0 1 3 2 ]


Each entry of the convolution is obtained by shifting the first row one position to the right, computing the product of each column, and summing all results.

In principle, the shifting should be done padding with zeros from the left. Equivalently, circular shifting can be used, because the matrix contains zeros at the appropriate entries.

For example, the first result is obtained from the shifted matrix

[ 0 5 3 4 1 0 0
0 0 0 0 1 3 2 ]


and is thus 1*1 == 1. The second is obtained from

[ 0 0 5 3 4 1 0
0 0 0 0 1 3 2 ]


and is thus 4*1+1*3 == 7, etc. This must be done m+n+1 times, where m and n are the input lengths. The code uses a loop with m+n iterations (which saves some bytes) and discards the last result.

P         % Take first input (numeric vactor) implicitly and reverse it
i         % Take second input (numeric vactor)
Yd        % Build diagonal matrix with the two vectors
t         % Duplicate
"         % For each column of the matrix
TF2&YS  %   Circularly shift first row 1 step to the right
t       %   Duplicate
p       %   Product of each column
s       %   Sum all results
w       %   Swap top two elements in stack. The shifted matrix is left on top
]         % End for
xx        % Delete matrix and last result. Implicitly display

2 added 734 characters in body
1