Convolution: the last element in the convolution is never right - c++

Question

I am writing a c++ implementation of convolution with the following function
vector<double> Conv(vector<double> a, vector<double> b)
{
// a and b are the same size
int n = a.size() * 2 - 1;
vector<double> c;
for (int i = 0; i < n; i++) {
c.push_back(0);
for (int j = 0; j <= i; j++) {
c[i] += a[j] * b[i - j];
}
}
return c;
}
The problem is that all the convolution values are correct except for the last one. I checked using a convolution calculator I found online.
Example input:
Vector a = <0.961232, 0.00685581, 0.905588, 0.914544>
Vector b = <0.719889, 0.675933, 0.0571511, 0.148412>
Returned vector = <0.691981, 0.654664, 0.711493, 1.41354, 0.670944, 0.186668, 0.653971>
Expected = <0.691980343248, 0.65466385166109, 0.71149237410793, 1.413537159886891, 0.67094330437252, 0.1866673218544, 0.135729304128>
The accuracy of the floats in the returned vector is fine, but the last result doesn't match up.

Answer 1

According to comments of other community members, I believe that your algorithm is not quite correct. Instead of debugging, I decided to find a correct one by google.
These two links gave me the clue:
Convolution of Vectors (Mlmode)
Convolution of two vectors in R
I used these links to make a small sample in C++:
#include <iostream>
#include <vector>
template <typename VALUE>
void convolve(
std::vector<VALUE> &c, // out
const std::vector<VALUE> &a, const std::vector<VALUE> &b) // in
{
const size_t nA = a.size(), nB = b.size();
const size_t nC = nA + nB - 1;
c.clear(); c.resize(nC, (VALUE)0);
for (size_t i = 0; i < nA; ++i) {
for (size_t j = 0; j < nB; ++j) {
c[i + j] += a[i] * b[j];
}
}
}
template <typename VALUE>
inline std::vector<VALUE> convolve(
const std::vector<VALUE> &a, const std::vector<VALUE> &b)
{
std::vector<VALUE> c; convolve(c, a, b); return c;
}
template <typename VALUE>
void print(
std::ostream &out, const char *label, const std::vector<VALUE> &vec)
{
out << label << '[' << vec.size() << "]: {";
const char *sep = " ";
for (const VALUE &v : vec) {
out << sep << v;
sep = ", ";
}
out << " }" << std::endl;
}
int main()
{
// test 1
// http://www.omatrix.com/manual/mlmode_conv.htm
{ std::cout << "Test 1:" << std::endl;
const std::vector<int> a = {
1, 1, 1, 1, 1
};
std::vector<int> c;
convolve(c, a, a);
print(std::cout, "a", a);
std::cout << "Convolution of a and a:" << std::endl;
print(std::cout, "c", c);
}
// test 2
{ std::cout << "Test 2:" << std::endl;
const std::vector<float> a = {
0.961232f, 0.00685581f, 0.905588f, 0.914544f
};
const std::vector<float> b = {
0.719889f, 0.675933f, 0.0571511f, 0.148412f
};
std::vector<float> c;
convolve(c, a, b);
print(std::cout, "a", a);
print(std::cout, "b", b);
std::cout << "Convolution of a and b:" << std::endl;
print(std::cout, "c", c);
}
// done
return 0;
}
Notes:
To copy a vector (as it is done in return) might be expensive for large vectors. Therefore, I provide the result vector by reference. (For those, who prefer return I wrote an inline wrapper but I didn't use it.)
Instead of vector::push_back(), I used vector::resize(). It is usually less expensive to do allocation at once (especially if size is known from beginning). The vector::resize() is also used for initialization. To discard possible previous values, a vector::clear() is done before. (vector::clear() is a cheap method because it does not free storage but simply resets internal number of elements.)
I made convolve a template. This makes the usage more flexible.
I compiled and tested it with g++ in cygwin on Windows 10 (64 bit):
$ g++ -std=c++11 -o vector-convolution vector-convolution.cc
$ ./vector-convolution.exe
Test 1:
a[5]: { 1, 1, 1, 1, 1 }
Convolution of a and a:
c[9]: { 1, 2, 3, 4, 5, 4, 3, 2, 1 }
Test 2:
a[4]: { 0.961232, 0.00685581, 0.905588, 0.914544 }
b[4]: { 0.719889, 0.675933, 0.0571511, 0.148412 }
Convolution of a and b:
c[7]: { 0.69198, 0.654664, 0.711492, 1.41354, 0.670943, 0.186667, 0.135729 }
$
This looks quite good:
Test 1 matches the expected values according to Convolution of Vectors (Mlmode).
Test 2 matches the expected values of your question.