Basic Templates for Linear Algebra

templates for simple linear algebra routines like BLAS level 1. More...

Functions

template<class Val>
void CH_Matrix_Classes::mat_xey (Integer len, Val *x, const Val *y)
 Copy an array of length len to destination x from source y.
template<class Val>
void CH_Matrix_Classes::mat_xey (Integer len, Val *x, const Integer incx, const Val *y, const Integer incy)
 Copy an array of length len to destination x (increment incx) from source y (increment incy).
template<class Val>
void CH_Matrix_Classes::mat_xemx (Integer len, Val *x)
 Set x[i]=-x[i] for an array of length len.
template<class Val>
void CH_Matrix_Classes::mat_xemx (Integer len, Val *x, const Integer incx)
 Set x[i]=-x[i] for len elements of an array incremented by incx.
template<class Val>
void CH_Matrix_Classes::mat_xemy (Integer len, Val *x, const Val *y)
 Set x[i]=-y[i] for len elements of the arrays x and y.
template<class Val>
void CH_Matrix_Classes::mat_xemy (Integer len, Val *x, const Integer incx, const Val *y, const Integer incy)
 Set x[i]=-y[i] for len elements of the arrays x and y incremented by incx and incy, respectively.
template<class Val>
void CH_Matrix_Classes::mat_xeya (Integer len, Val *x, const Val *y, Val a)
 Set x[i]=a*y[i] for len elements of the arrays x and y.
template<class Val>
void CH_Matrix_Classes::mat_xeya (Integer len, Val *x, const Integer incx, const Val *y, const Integer incy, Val a)
 Set x[i]=a*y[i] for len elements of the arrays x and y incremented by incx and incy, respectively.
template<class Val>
void CH_Matrix_Classes::mat_xpey (Integer len, Val *x, const Val *y)
 Set x[i]+=y[i] for len elements of the arrays x and y.
template<class Val>
void CH_Matrix_Classes::mat_xpey (Integer len, Val *x, const Integer incx, const Val *y, const Integer incy)
 Set x[i]+=y[i] for len elements of the arrays x and y incremented by incx and incy, respectively.
template<class Val>
void CH_Matrix_Classes::mat_xmey (Integer len, Val *x, const Val *y)
 Set x[i]=-y[i] for len elements of the arrays x and y.
template<class Val>
void CH_Matrix_Classes::mat_xmey (Integer len, Val *x, const Integer incx, const Val *y, const Integer incy)
 Set x[i]=-y[i] for len elements of the arrays x and y incremented by incx and incy, respectively.
template<class Val>
void CH_Matrix_Classes::mat_xhadey (Integer len, Val *x, const Val *y)
 Set x[i]*=y[i] for len elements of the arrays x and y.
template<class Val>
void CH_Matrix_Classes::mat_xinvhadey (Integer len, Val *x, const Val *y)
 Set x[i]/=y[i] for len elements of the arrays x and y, no zero checking!
template<class Val>
void CH_Matrix_Classes::mat_xhadey (Integer len, Val *x, const Integer incx, const Val *y, const Integer incy)
 Set x[i]*=y[i] for len elements of the arrays x and y incremented by incx and incy, respectively.
template<class Val>
void CH_Matrix_Classes::mat_xinvhadey (Integer len, Val *x, const Integer incx, const Val *y, const Integer incy)
 Set x[i]/=y[i] for len elements of the arrays x and y incremented by incx and incy, respectively, no zero checking!
template<class Val>
void CH_Matrix_Classes::mat_xpeya (Integer len, Val *x, const Val *y, Val a)
 Set x[i]+=a*y[i] for len elements of the arrays x and y.
template<class Val>
void CH_Matrix_Classes::mat_xpeya (Integer len, Val *x, const Integer incx, const Val *y, const Integer incy, Val a)
 Set x[i]+=a*y[i] for len elements of the arrays x and y incremented by incx and incy, respectively.
template<class Val>
void CH_Matrix_Classes::mat_xbpeya (Integer len, Val *x, const Val *y, Val a, Val b)
 Set x[i]=a*y[i]+b*x[i] for len elements of the arrays x and y.
template<class Val>
void CH_Matrix_Classes::mat_xbpeya (Integer len, Val *x, const Integer incx, const Val *y, const Integer incy, Val a, Val b)
 Set x[i]=a*y[i]+b*x[i] for len elements of the arrays x and y incremented by incx and incy, respectively.
template<class Val>
void CH_Matrix_Classes::mat_xea (Integer len, Val *x, Val a)
 Set x[i]=a for len elements of the array x.
template<class Val>
void CH_Matrix_Classes::mat_xea (Integer len, Val *x, const Integer incx, Val a)
 Set x[i]=a for len elements of the array x incremented by incx.
template<class Val>
void CH_Matrix_Classes::mat_xpea (Integer len, Val *x, Val a)
 Set x[i]+=a for len elements of the array x.
template<class Val>
void CH_Matrix_Classes::mat_xpea (Integer len, Val *x, const Integer incx, Val a)
 Set x[i]+=a for len elements of the array x incremented by incx.
template<class Val>
void CH_Matrix_Classes::mat_xmultea (Integer len, Val *x, Val a)
 Set x[i]*=a for len elements of the array x.
template<class Val>
void CH_Matrix_Classes::mat_xmultea (Integer len, Val *x, const Integer incx, Val a)
 Set x[i]*=a for len elements of the array x incremented by incx.
template<class Val>
void CH_Matrix_Classes::mat_xdivea (Integer len, Val *x, Val a)
 Set x[i]/=a for len elements of the array x.
template<class Val>
void CH_Matrix_Classes::mat_xdivea (Integer len, Val *x, const Integer incx, Val a)
 Set x[i]/=a for len elements of the array x incremented by incx.
template<class Val>
void CH_Matrix_Classes::mat_xmodea (Integer len, Val *x, Val a)
 Set x[i]=a for len elements of the array x.
template<class Val>
void CH_Matrix_Classes::mat_xmodea (Integer len, Val *x, const Integer incx, Val a)
 Set x[i]=a for len elements of the array x incremented by incx.
template<class Val>
void CH_Matrix_Classes::mat_xeypz (Integer len, Val *x, const Val *y, const Val *z)
 Set x[i]=y[i]+z[i] for len elements of the arrays x, y and z.
template<class Val>
void CH_Matrix_Classes::mat_xeypz (Integer len, Val *x, const Integer incx, const Val *y, const Integer incy, const Val *z, const Integer incz)
 Set x[i]=y[i]+z[i] for len elements of the arrays x, y and z incremented by incx, incy, and incz, respectively.
template<class Val>
void CH_Matrix_Classes::mat_xeymz (Integer len, Val *x, const Val *y, const Val *z)
 Set x[i]=y[i]-z[i] for len elements of the arrays x, y and z.
template<class Val>
void CH_Matrix_Classes::mat_xeymz (Integer len, Val *x, const Integer incx, const Val *y, const Integer incy, const Val *z, const Integer incz)
 Set x[i]=y[i]-z[i] for len elements of the arrays x, y and z incremented by incx, incy, and incz, respectively.
template<class Val>
void CH_Matrix_Classes::mat_xeyapzb (Integer len, Val *x, const Val *y, const Val *z, Val a, Val b)
 Set x[i]=a*y[i]+b*z[i] for len elements of the arrays x, y and z.
template<class Val>
void CH_Matrix_Classes::mat_xeyapzb (Integer len, Val *x, const Integer incx, const Val *y, const Integer incy, const Val *z, const Integer incz, Val a, Val b)
 Set x[i]=a*y[i]+b*z[i] for len elements of the arrays x, y and z incremented by incx, incy, and incz, respectively.
template<class Val>
Val CH_Matrix_Classes::mat_ip (Integer len, const Val *x, const Val *y)
 return sum(x[i]*y[i]) summing over len elements of the arrays x and y.
template<class Val>
Val CH_Matrix_Classes::mat_ip (Integer len, const Val *x, const Integer incx, const Val *y, const Integer incy)
 return sum(x[i]*y[i]) summing over len elements of the arrays x and y incremented by incx and incy, respectively.
template<class Val>
Val CH_Matrix_Classes::mat_ip (Integer len, const Val *x)
 return sum(x[i]*x[i]) summing over len elements of the array x.
template<class Val>
Val CH_Matrix_Classes::mat_ip (Integer len, const Val *x, const Integer incx)
 return sum(x[i]*x[i]) summing over len elements of the array x incremented by incx.
template<class Val>
Val CH_Matrix_Classes::mat_sum (Integer len, const Val *x)
 returns sum(x[i]) over len elements of the array x.
template<class Val>
Val CH_Matrix_Classes::mat_sum (Integer len, const Val *x, const Integer incx)
 returns sum(x[i]) over len elements of the array x incremented by incx.
template<class Val>
void CH_Matrix_Classes::mat_swap (Integer len, Val *x, Val *y)
 swap values x[i] and y[i] for len elements of the arrays x and y.
template<class Val>
void CH_Matrix_Classes::mat_swap (Integer len, Val *x, const Integer incx, Val *y, const Integer incy)
 swap values x[i] and y[i] for len elements of the arrays x and y incremented by incx and incy, respectively.

Detailed Description

templates for simple linear algebra routines like BLAS level 1.


Function Documentation

template<class Val>
Val CH_Matrix_Classes::mat_ip ( Integer  len,
const Val *  x,
const Integer  incx 
) [inline]

return sum(x[i]*x[i]) summing over len elements of the array x incremented by incx.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the destination
incx gives the increment for x in each step
Returns:
sum_{i=0}^{len} x[i*incx] * x[i*incx]

template<class Val>
Val CH_Matrix_Classes::mat_ip ( Integer  len,
const Val *  x 
) [inline]

return sum(x[i]*x[i]) summing over len elements of the array x.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the array
Returns:
sum_{i=0}^{len} x[i] * x[i]

template<class Val>
Val CH_Matrix_Classes::mat_ip ( Integer  len,
const Val *  x,
const Integer  incx,
const Val *  y,
const Integer  incy 
) [inline]

return sum(x[i]*y[i]) summing over len elements of the arrays x and y incremented by incx and incy, respectively.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the x array
incx gives the increment for x in each step
y points to the starting address of the y array
incy gives the increment for y in each step
Returns:
sum_{i=0}^{len} x[i*incx] * y[i*incy]

template<class Val>
Val CH_Matrix_Classes::mat_ip ( Integer  len,
const Val *  x,
const Val *  y 
) [inline]

return sum(x[i]*y[i]) summing over len elements of the arrays x and y.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the x array
y points to the starting address of the y array
Returns:
sum_{i=0}^{len} x[i] * y[i]

template<class Val>
Val CH_Matrix_Classes::mat_sum ( Integer  len,
const Val *  x,
const Integer  incx 
) [inline]

returns sum(x[i]) over len elements of the array x incremented by incx.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the first array
incx gives the increment for x in each step
Returns:
sum_{i=0}^{len} x[i*incx]

template<class Val>
Val CH_Matrix_Classes::mat_sum ( Integer  len,
const Val *  x 
) [inline]

returns sum(x[i]) over len elements of the array x.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the first array
Returns:
sum_{i=0}^{len} x[i]

template<class Val>
void CH_Matrix_Classes::mat_swap ( Integer  len,
Val *  x,
const Integer  incx,
Val *  y,
const Integer  incy 
) [inline]

swap values x[i] and y[i] for len elements of the arrays x and y incremented by incx and incy, respectively.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the first array
incx gives the increment for x in each step
y points to the starting address of the second array
incy gives the increment for y in each step

template<class Val>
void CH_Matrix_Classes::mat_swap ( Integer  len,
Val *  x,
Val *  y 
) [inline]

swap values x[i] and y[i] for len elements of the arrays x and y.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the first array
y points to the starting address of the second array

template<class Val>
void CH_Matrix_Classes::mat_xbpeya ( Integer  len,
Val *  x,
const Integer  incx,
const Val *  y,
const Integer  incy,
Val  a,
Val  b 
) [inline]

Set x[i]=a*y[i]+b*x[i] for len elements of the arrays x and y incremented by incx and incy, respectively.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the destination
incx gives the increment for x in each step
y points to the starting address of the source
incy gives the increment for y in each step
a is the multiplicative factor for y
b is the multiplicative factor for x

template<class Val>
void CH_Matrix_Classes::mat_xbpeya ( Integer  len,
Val *  x,
const Val *  y,
Val  a,
Val  b 
) [inline]

Set x[i]=a*y[i]+b*x[i] for len elements of the arrays x and y.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the destination
y points to the starting address of the source
a is the multiplicative factor for y
b is the multiplicative factor for x

template<class Val>
void CH_Matrix_Classes::mat_xdivea ( Integer  len,
Val *  x,
const Integer  incx,
Val  a 
) [inline]

Set x[i]/=a for len elements of the array x incremented by incx.

Parameters:
len gives the number of elements to be processed
x points to the starting address
incx gives the increment for x in each step
a is the scalar value (it is not checked whether a is zero)

template<class Val>
void CH_Matrix_Classes::mat_xdivea ( Integer  len,
Val *  x,
Val  a 
) [inline]

Set x[i]/=a for len elements of the array x.

Parameters:
len gives the number of elements to be processed
x points to the starting address
a is the scalar value (it is not checked whether a is zero)

template<class Val>
void CH_Matrix_Classes::mat_xea ( Integer  len,
Val *  x,
const Integer  incx,
Val  a 
) [inline]

Set x[i]=a for len elements of the array x incremented by incx.

Parameters:
len gives the number of elements to be processed
x points to the starting address
incx gives the increment for x in each step
a is the scalar value

template<class Val>
void CH_Matrix_Classes::mat_xea ( Integer  len,
Val *  x,
Val  a 
) [inline]

Set x[i]=a for len elements of the array x.

Parameters:
len gives the number of elements to be processed
x points to the starting address
a is the scalar value

Referenced by CH_Matrix_Classes::Symmatrix::init(), CH_Matrix_Classes::Matrix::init(), and CH_Matrix_Classes::Indexmatrix::init().

template<class Val>
void CH_Matrix_Classes::mat_xemx ( Integer  len,
Val *  x,
const Integer  incx 
) [inline]

Set x[i]=-x[i] for len elements of an array incremented by incx.

Parameters:
len gives the number of elements
x points to the starting address
incx gives the increment for x in each step

template<class Val>
void CH_Matrix_Classes::mat_xemx ( Integer  len,
Val *  x 
) [inline]

Set x[i]=-x[i] for an array of length len.

Parameters:
len gives the number of elements
x points to the starting address

template<class Val>
void CH_Matrix_Classes::mat_xemy ( Integer  len,
Val *  x,
const Integer  incx,
const Val *  y,
const Integer  incy 
) [inline]

Set x[i]=-y[i] for len elements of the arrays x and y incremented by incx and incy, respectively.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the destination
incx gives the increment for x in each step
y points to the starting address of the source
incy gives the increment for y in each step

template<class Val>
void CH_Matrix_Classes::mat_xemy ( Integer  len,
Val *  x,
const Val *  y 
) [inline]

Set x[i]=-y[i] for len elements of the arrays x and y.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the destination
y points to the starting address of the source

template<class Val>
void CH_Matrix_Classes::mat_xey ( Integer  len,
Val *  x,
const Integer  incx,
const Val *  y,
const Integer  incy 
) [inline]

Copy an array of length len to destination x (increment incx) from source y (increment incy).

Parameters:
len gives the number of elements to be processed
x points to the starting address of the destination
incx gives the increment for x in each step
y points to the starting address of the source
incy gives the increment for y in each step

template<class Val>
void CH_Matrix_Classes::mat_xey ( Integer  len,
Val *  x,
const Val *  y 
) [inline]

Copy an array of length len to destination x from source y.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the destination
y points to the starting address of the source

Referenced by CH_Matrix_Classes::Symmatrix::init(), CH_Matrix_Classes::Matrix::init(), and CH_Matrix_Classes::Indexmatrix::init().

template<class Val>
void CH_Matrix_Classes::mat_xeya ( Integer  len,
Val *  x,
const Integer  incx,
const Val *  y,
const Integer  incy,
Val  a 
) [inline]

Set x[i]=a*y[i] for len elements of the arrays x and y incremented by incx and incy, respectively.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the destination
incx gives the increment for x in each step
y points to the starting address of the source
incy gives the increment for y in each step
a is the multiplicative factor

template<class Val>
void CH_Matrix_Classes::mat_xeya ( Integer  len,
Val *  x,
const Val *  y,
Val  a 
) [inline]

Set x[i]=a*y[i] for len elements of the arrays x and y.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the destination
y points to the starting address of the source
a is the multiplicative factor

template<class Val>
void CH_Matrix_Classes::mat_xeyapzb ( Integer  len,
Val *  x,
const Integer  incx,
const Val *  y,
const Integer  incy,
const Val *  z,
const Integer  incz,
Val  a,
Val  b 
) [inline]

Set x[i]=a*y[i]+b*z[i] for len elements of the arrays x, y and z incremented by incx, incy, and incz, respectively.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the destination
incx gives the increment for x in each step
y points to the starting address of the first source
incy gives the increment for y in each step
z points to the starting address of the second source
incz gives the increment for z in each step
a is the multiplicative factor for y
b is the multiplicative factor for z

template<class Val>
void CH_Matrix_Classes::mat_xeyapzb ( Integer  len,
Val *  x,
const Val *  y,
const Val *  z,
Val  a,
Val  b 
) [inline]

Set x[i]=a*y[i]+b*z[i] for len elements of the arrays x, y and z.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the destination
y points to the starting address of the first source
z points to the starting address of the second source
a is the multiplicative factor for y
b is the multiplicative factor for z

template<class Val>
void CH_Matrix_Classes::mat_xeymz ( Integer  len,
Val *  x,
const Integer  incx,
const Val *  y,
const Integer  incy,
const Val *  z,
const Integer  incz 
) [inline]

Set x[i]=y[i]-z[i] for len elements of the arrays x, y and z incremented by incx, incy, and incz, respectively.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the destination
incx gives the increment for x in each step
y points to the starting address of the first source
incy gives the increment for y in each step
z points to the starting address of the second source
incz gives the increment for z in each step

template<class Val>
void CH_Matrix_Classes::mat_xeymz ( Integer  len,
Val *  x,
const Val *  y,
const Val *  z 
) [inline]

Set x[i]=y[i]-z[i] for len elements of the arrays x, y and z.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the destination
y points to the starting address of the first source
z points to the starting address of the second source

template<class Val>
void CH_Matrix_Classes::mat_xeypz ( Integer  len,
Val *  x,
const Integer  incx,
const Val *  y,
const Integer  incy,
const Val *  z,
const Integer  incz 
) [inline]

Set x[i]=y[i]+z[i] for len elements of the arrays x, y and z incremented by incx, incy, and incz, respectively.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the destination
incx gives the increment for x in each step
y points to the starting address of the first source
incy gives the increment for y in each step
z points to the starting address of the second source
incz gives the increment for z in each step

template<class Val>
void CH_Matrix_Classes::mat_xeypz ( Integer  len,
Val *  x,
const Val *  y,
const Val *  z 
) [inline]

Set x[i]=y[i]+z[i] for len elements of the arrays x, y and z.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the destination
y points to the starting address of the first source
z points to the starting address of the second source

template<class Val>
void CH_Matrix_Classes::mat_xhadey ( Integer  len,
Val *  x,
const Integer  incx,
const Val *  y,
const Integer  incy 
) [inline]

Set x[i]*=y[i] for len elements of the arrays x and y incremented by incx and incy, respectively.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the destination
incx gives the increment for x in each step
y points to the starting address of the source
incy gives the increment for y in each step

template<class Val>
void CH_Matrix_Classes::mat_xhadey ( Integer  len,
Val *  x,
const Val *  y 
) [inline]

Set x[i]*=y[i] for len elements of the arrays x and y.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the destination
y points to the starting address of the source

Referenced by CH_Matrix_Classes::Symmatrix::operator%=(), CH_Matrix_Classes::Matrix::operator%=(), and CH_Matrix_Classes::Indexmatrix::operator%=().

template<class Val>
void CH_Matrix_Classes::mat_xinvhadey ( Integer  len,
Val *  x,
const Integer  incx,
const Val *  y,
const Integer  incy 
) [inline]

Set x[i]/=y[i] for len elements of the arrays x and y incremented by incx and incy, respectively, no zero checking!

Parameters:
len gives the number of elements to be processed
x points to the starting address of the destination
incx gives the increment for x in each step
y points to the starting address of the source
incy gives the increment for y in each step

template<class Val>
void CH_Matrix_Classes::mat_xinvhadey ( Integer  len,
Val *  x,
const Val *  y 
) [inline]

Set x[i]/=y[i] for len elements of the arrays x and y, no zero checking!

Parameters:
len gives the number of elements to be processed
x points to the starting address of the destination
y points to the starting address of the source

Referenced by CH_Matrix_Classes::Matrix::operator/=().

template<class Val>
void CH_Matrix_Classes::mat_xmey ( Integer  len,
Val *  x,
const Integer  incx,
const Val *  y,
const Integer  incy 
) [inline]

Set x[i]=-y[i] for len elements of the arrays x and y incremented by incx and incy, respectively.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the destination
incx gives the increment for x in each step
y points to the starting address of the source
incy gives the increment for y in each step

template<class Val>
void CH_Matrix_Classes::mat_xmey ( Integer  len,
Val *  x,
const Val *  y 
) [inline]

Set x[i]=-y[i] for len elements of the arrays x and y.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the destination
y points to the starting address of the source

template<class Val>
void CH_Matrix_Classes::mat_xmodea ( Integer  len,
Val *  x,
const Integer  incx,
Val  a 
) [inline]

Set x[i]=a for len elements of the array x incremented by incx.

Parameters:
len gives the number of elements to be processed
x points to the starting address
incx gives the increment for x in each step
a is the scalar value (it is not checked whether a is zero)

template<class Val>
void CH_Matrix_Classes::mat_xmodea ( Integer  len,
Val *  x,
Val  a 
) [inline]

Set x[i]=a for len elements of the array x.

Parameters:
len gives the number of elements to be processed
x points to the starting address
a is the scalar value (it is not checked whether a is zero)

template<class Val>
void CH_Matrix_Classes::mat_xmultea ( Integer  len,
Val *  x,
const Integer  incx,
Val  a 
) [inline]

Set x[i]*=a for len elements of the array x incremented by incx.

Parameters:
len gives the number of elements to be processed
x points to the starting address
incx gives the increment for x in each step
a is the scalar value

template<class Val>
void CH_Matrix_Classes::mat_xmultea ( Integer  len,
Val *  x,
Val  a 
) [inline]

Set x[i]*=a for len elements of the array x.

Parameters:
len gives the number of elements to be processed
x points to the starting address
a is the scalar value

Referenced by CH_Matrix_Classes::Symmatrix::operator/=().

template<class Val>
void CH_Matrix_Classes::mat_xpea ( Integer  len,
Val *  x,
const Integer  incx,
Val  a 
) [inline]

Set x[i]+=a for len elements of the array x incremented by incx.

Parameters:
len gives the number of elements to be processed
x points to the starting address
incx gives the increment for x in each step
a is the scalar value

template<class Val>
void CH_Matrix_Classes::mat_xpea ( Integer  len,
Val *  x,
Val  a 
) [inline]

Set x[i]+=a for len elements of the array x.

Parameters:
len gives the number of elements to be processed
x points to the starting address
a is the scalar value

Referenced by CH_Matrix_Classes::Symmatrix::operator+=(), and CH_Matrix_Classes::Symmatrix::operator-=().

template<class Val>
void CH_Matrix_Classes::mat_xpey ( Integer  len,
Val *  x,
const Integer  incx,
const Val *  y,
const Integer  incy 
) [inline]

Set x[i]+=y[i] for len elements of the arrays x and y incremented by incx and incy, respectively.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the destination
incx gives the increment for x in each step
y points to the starting address of the source
incy gives the increment for y in each step

template<class Val>
void CH_Matrix_Classes::mat_xpey ( Integer  len,
Val *  x,
const Val *  y 
) [inline]

Set x[i]+=y[i] for len elements of the arrays x and y.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the destination
y points to the starting address of the source

template<class Val>
void CH_Matrix_Classes::mat_xpeya ( Integer  len,
Val *  x,
const Integer  incx,
const Val *  y,
const Integer  incy,
Val  a 
) [inline]

Set x[i]+=a*y[i] for len elements of the arrays x and y incremented by incx and incy, respectively.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the destination
incx gives the increment for x in each step
y points to the starting address of the source
incy gives the increment for y in each step
a is the multiplicative factor

template<class Val>
void CH_Matrix_Classes::mat_xpeya ( Integer  len,
Val *  x,
const Val *  y,
Val  a 
) [inline]

Set x[i]+=a*y[i] for len elements of the arrays x and y.

Parameters:
len gives the number of elements to be processed
x points to the starting address of the destination
y points to the starting address of the source
a is the multiplicative factor


Generated on Tue May 3 16:52:54 2011 for ConicBundle by  doxygen 1.5.6