function sspmv( order, uplo, N, alpha, AP, x, strideX, beta, y, strideY ) {
	var temp1;
	var temp2;
	var ix;
	var iy;
	var jx;
	var jy;
	var kk;
	var kx;
	var ky;
	var sy;
	var j;
	var k;

	if ( !isLayout( order ) ) {
		throw new TypeError( 'invalid argument. First argument must be a valid order. Value: `%s`.', order );
	}
	if ( !isMatrixTriangle( uplo ) ) {
		throw new TypeError( 'invalid argument. Second argument must specify whether the lower or upper triangular matrix is supplied. Value: `%s`.', uplo );
	}
	if ( N < 0 ) {
		throw new RangeError( 'invalid argument. Third argument must be a nonnegative integer. Value: `%d`.', N );
	}
	if ( strideX === 0 ) {
		throw new RangeError( 'invalid argument. Seventh argument must be non-zero. Value: `%d`.', strideX );
	}
	if ( strideY === 0 ) {
		throw new RangeError( 'invalid argument. Tenth argument must be non-zero. Value: `%d`.', strideY );
	}
	if ( N === 0 || ( alpha === 0.0 && beta === 1.0 ) ) {
		return y;
	}
	// Form: y = beta*y
	sy = strideY;
	if ( beta !== 1.0 ) {
		if ( beta === 0.0 ) {
			sfill( N, 0.0, y, strideY );
		} else {
			if ( strideY < 0 ) {
				sy = -sy;
			}
			sscal( N, beta, y, sy );
		}
	}
	if ( alpha === 0.0 ) {
		return y;
	}
	if ( strideX > 0 ) {
		kx = 0;
	} else {
		kx = ( 1 - N ) * strideX;
	}
	if ( strideY > 0 ) {
		ky = 0;
	} else {
		ky = ( 1 - N ) * strideY;
	}
	// Form: y = alpha*A*x + y
	kk = 0;
	if (
		( isRowMajor( order ) && uplo === 'upper' ) ||
		( isColumnMajor( order ) && uplo === 'lower' )
	) {
		jx = kx;
		jy = ky;
		for ( j = 0; j < N; j++ ) {
			temp1 = f32( alpha * x[ jx ] );
			temp2 = 0.0;
			y[ jy ] += f32( temp1 * AP[ kk ] );
			ix = jx;
			iy = jy;
			for ( k = kk + 1; k < kk + N - j; k++ ) {
				ix += strideX;
				iy += strideY;
				y[ iy ] += f32( temp1 * AP[ k ] );
				temp2 += f32( AP[ k ] * x[ ix ] );
			}
			y[ jy ] += f32( alpha * temp2 );
			jx += strideX;
			jy += strideY;
			kk += N - j;
		}
		return y;
	}
	// ( order === 'row-major' && uplo === 'lower') || ( order === 'column-major' && uplo === 'upper' )
	jx = kx;
	jy = ky;
	for ( j = 0; j < N; j++ ) {
		temp1 = f32( alpha * x[ jx ] );
		temp2 = 0.0;
		ix = kx;
		iy = ky;
		for ( k = kk; k < kk + j; k++ ) {
			y[ iy ] += f32( temp1 * AP[ k ] );
			temp2 += f32( AP[ k ] * x[ ix ] );
			ix += strideX;
			iy += strideY;
		}
		y[ jy ] += f32( f32( temp1 * AP[ kk + j ] ) + f32( alpha * temp2 ) );
		jx += strideX;
		jy += strideY;
		kk += j + 1;
	}
	return y;
}
Performs the matrix-vector operation `y = alpha*A*x + beta*y` where `alpha` and `beta` are scalars, `x` and `y` are `N` element vectors, and `A` is an `N` by `N` symmetric matrix supplied in packed form.

@param {string} order - storage layout
@param {string} uplo - specifies whether the upper or lower triangular part of the symmetric matrix `A` is supplied
@param {NonNegativeInteger} N - number of elements along each dimension of `A`
@param {number} alpha - scalar constant
@param {Float32Array} AP - packed form of a symmetric matrix `A`
@param {Float32Array} x - first input array
@param {integer} strideX - `x` stride length
@param {number} beta - scalar constant
@param {Float32Array} y - second input array
@param {integer} strideY - `y` stride length
@throws {TypeError} first argument must be a valid order
@throws {TypeError} second argument must specify whether the lower or upper triangular matrix is supplied
@throws {RangeError} third argument must be a nonnegative integer
@throws {RangeError} seventh argument must be non-zero
@throws {RangeError} tenth argument must be non-zero
@returns {Float32Array} `y`

@example
var Float32Array = require( '@stdlib/array/float32' );

var AP = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
var x = new Float32Array( [ 1.0, 1.0, 1.0 ] );
var y = new Float32Array( [ 1.0, 1.0, 1.0 ] );

sspmv( 'column-major', 'lower', 3, 1.0, AP, x, 1, 1.0, y, 1 );
// y => <Float32Array>[ ~7.0, ~12.0, ~15.0 ]