Matrix arithmetic operations I am currently attempting to implement Matrix Math for another project I am working on.

However, I am not sure whether this implementation will work. Can someone please tell me if there are any errors with my implementation?

#include &lt;iostream&gt;
#include &lt;vector&gt;
#include &lt;cassert&gt;

using namespace std;

typedef vector&lt;vector&lt;double&gt; &gt; Matrix;

Matrix add(Matrix a, Matrix b)
{
  assert(a.size() == b.size() &amp;&amp; a[0].size() == b[0].size());

  int numRow = a.size(), numCol = a[0].size();
  Matrix output(numRow, vector&lt;double&gt;(numCol));

  for(int i = 0; i &lt; numRow; i++)
  {
    for(int j = 0; j &lt; numCol; j++)
    {
      output[i][j] = a[i][j] + b[i][j];
    }
  }

  return output;
}

Matrix subtract(Matrix a, Matrix b)
{
  assert(a.size() == b.size() &amp;&amp; a[0].size() == b[0].size());

  int numRow = a.size(), numCol = a[0].size();
  Matrix output(numRow, vector&lt;double&gt;(numCol));

  for(int i = 0; i &lt; numRow; i++)
  {
    for(int j = 0; j &lt; numCol; j++)
    {
      output[i][j] = a[i][j] - b[i][j];
    }
  }

  return output;
}

Matrix multiply(Matrix a, double b)
{
  int numRow = a.size(), numCol = a[0].size();
  Matrix output(numRow, vector&lt;double&gt;(numCol));

  for(int i = 0; i &lt; numRow; i++)
  {
    for(int j = 0; j &lt; numCol; j++)
    {
      output[i][j] = a[i][j] * b;
    }
  }

  return output;
}

Matrix multiply(Matrix a, Matrix b)
{
  assert(a.size() == b.size() &amp;&amp; a[0].size() == b[0].size());

  int numRow = a.size(), numCol = a[0].size();
  Matrix output(numRow, vector&lt;double&gt;(numCol));

  for(int i = 0; i &lt; numRow; i++)
  {
    for(int j = 0; j &lt; numCol; j++)
    {
      output[i][j] = a[i][j] * b[i][j];
    }
  }

  return output;
}

Matrix dotProduct(Matrix a, Matrix b)
{
  assert(a[0].size() == b.size());

  int numRow = a.size(), numCol = b[0].size();
  Matrix output(numRow, vector&lt;double&gt;(numCol, 0));

  for(int i = 0; i &lt; numRow; i++)
  {
    for(int j = 0; j &lt; numCol; j++)
    {
      for(unsigned int k = 0; k &lt; a[0].size(); k++)
      {
        output[i][j] += a[i][k] * b[k][j];
      }
    }
  }

  return output;
}

Matrix transpose(Matrix a)
{
  int numRow = a[0].size(), numCol = a.size();
  Matrix output(numRow, vector&lt;double&gt;(numCol));

  for(int i = 0; i &lt; numRow; i++)
  {
    for(int j = 0; j &lt; numCol; j++)
    {
      output[i][j] = a[j][i];
    }
  }

  return output;
}

Matrix applyFunc(Matrix a, double (*f)(double))
{
  int numRow = a.size(), numCol = a[0].size();
  Matrix output(numRow, vector&lt;double&gt;(numCol));

  for(int i = 0; i &lt; numRow; i++)
  {
    for(int j = 0; j &lt; numCol; j++)
    {
      output[i][j] = (*f)(a[i][j]);
    }
  }

  return output;
}

int main()
{

}
Overview
Sure this is one way to represent a Matrix.
typedef vector&lt;vector&lt;double&gt; &gt; Matrix;

The problem here is that there is no enforcement that these are rectangular. Your code makes the assumption they are rectangles and things will go very wrong if the assumption is wrong.
You don't use encapsulation.
Matrix add(Matrix a, Matrix b)
Matrix subtract(Matrix a, Matrix b)
Matrix multiply(Matrix a, double b)
Matrix multiply(Matrix a, Matrix b)
Matrix dotProduct(Matrix a, Matrix b)

All these are standalone methods. Not an absolute no-no but using classes correctly you can enforce the rectangular size requirements (preferably at compile time) but you could do it at runtime. If you use these methods then these would normally be member functions.
Also these functions are just wrong:
Matrix multiply(Matrix a, Matrix b)
Matrix dotProduct(Matrix a, Matrix b)

Neither of these functions do what they advertise. You should check out wikipedia for the definitions.