Method mv_generic

src/ialglib.cpp:121–254

This is generic C implementation of mv. It may work with unaligned data. ********************************************************************/

It may work with unaligned data.
********************************************************************/
void ialglib::mv_generic(int m, int n, const double *a, const double *x, double *y, int stride, double alpha, double beta)
{
    if( m==32 && n==32 )
    {
        //
        // 32x32, may be we have something better than general implementation
        //
        mv_32(a, x, y, stride, alpha, beta);
    }
    else
    {
        int i, k, m2, n8, n2, ntrail2;
        const double *pa0, *pa1, *pb;

        //
        // First M/2 rows of A are processed in pairs.
        // Highly optimized code is used.
        //
        m2 = m/2;
        n8 = n/8;
        ntrail2 = (n-8*n8)/2;
        for(i=0; i<m2; i++)
        {
            double v0 = 0, v1 = 0;

            //
            // 'a' points to the part of the matrix which
            // is not processed yet
            //
            pb = x;
            pa0 = a;
            pa1 = a+alglib_r_block;
            a += alglib_twice_r_block;

            //
            // 8 elements per iteration
            //
            for(k=0; k<n8; k++)
            {
                v0 += pa0[0]*pb[0];
                v1 += pa1[0]*pb[0];
                v0 += pa0[1]*pb[1];
                v1 += pa1[1]*pb[1];
                v0 += pa0[2]*pb[2];
                v1 += pa1[2]*pb[2];
                v0 += pa0[3]*pb[3];
                v1 += pa1[3]*pb[3];
                v0 += pa0[4]*pb[4];
                v1 += pa1[4]*pb[4];
                v0 += pa0[5]*pb[5];
                v1 += pa1[5]*pb[5];
                v0 += pa0[6]*pb[6];
                v1 += pa1[6]*pb[6];
                v0 += pa0[7]*pb[7];
                v1 += pa1[7]*pb[7];
                pa0 += 8;
                pa1 += 8;
                pb  += 8;