Question

I got some code off the Internet and now I just need help to multiply elements of two matrices or vectors.

Matrixf multiply(Matrixf const& left, Matrixf const& right) {

    // Error check
    if (left.ncols() != right.nrows()) {
        throw std::runtime_error("Unable to multiply: matrix dimensions not agree.");
    }

    /* I have all the other part of the code for matrix */

    /** Now I am not sure how to implement multiplication of a vector or matrix. **/

    Matrixf ret(1, 1);

    return ret;
}

Background: I am a new C++ user and I am also doing a major in mathematics, so thought I would try implement a simple calculator.

Answer 1

I’d recommend you use a library such as Eigen (very fast) or the Boost uBLAS matrix (not so fast, relatively speaking) class. Still, if you’re trying to learn the way to do this, there’s no harm in building your own class. The standard way of doing this is with templates for the type. You can also, with a little bit of further investigation use templates for the size (left as an exercise to the reader).

template <typename T> class matrix
{
private:
    T *_m;
    std::size_t _rows;
    std::size_t _cols;

public:
    matrix(std::size_t rows, std::size_t cols)
      : _m(new T[rows*cols]), _rows(rows), _cols(cols) {}

    matrix(matrix<T>&& src)
      : _m(src._m), _rows(src._rows), _cols(src._cols)
    {
        src._m = NULL;
        src._rows = 0;
        src._cols = 0;
    }

    matrix<T>& operator=(matrix<T>&& src)
    {
        delete[] this->_m;
        this->_m = src._m;
        this->_rows = src._rows;
        this->_cols = src._cols;
        src._m = NULL;
        src._rows = 0;
        src._cols = 0;

        return *this;
    }

    virtual ~matrix()
    {
        delete[] this->_m;
    }

    inline float& operator()(std::size_t r, std::size_t c)
    {
        assert(r < this->_rows && c < this->_cols);
        return this->_m[r*this->_cols + c];
    }

    inline std::size_t rows() { return this->_rows; }
    inline std::size_t cols() { return this->_cols; }
};

template <typename T>
matrix<T> operator*(const matrix<T>& l, const matrix<T>& r)
{
    assert(l.cols() == r.rows());
    matrix<T> rv(l.rows(), r.cols());

    for (std::size_t r = 0; r < rv.rows(); ++r)
        for (std::size_t c = 0; c < rv.cols(); ++c);
        {
            rv(r, c) = (T) 0;
            for (std::size_t i = 0; i < l.cols(); ++i)
                rv(r, c) += l(r, i) * r(i, c);
        }

    return rv;
}

This has a few C++11 aspects to it, namely the move constructor and assignment operator. If you are not using C++11 yet, replace them with traditional copy and assignment operators respectively. Also, this is a kind of naive multiplier. There are some efficiencies you can employ to eliminate many of the matrix element lookups by replacing them with an iterator style construct instead.