ConicBundle
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_xea (Integer len, Val *x, const Val a)
Set x[i]=a for len elements of the array x. More...

template<class Val >
void CH_Matrix_Classes::mat_xea (Integer len, Val *x, const Integer incx, const Val a)
Set x[i]=a for len elements of the array x incremented by incx. More...

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. More...

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). More...

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. More...

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. More...

template<class Val >
void CH_Matrix_Classes::mat_xemx (Integer len, Val *x)
Set x[i]=-x[i] for an array of length len. More...

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. More...

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. More...

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. More...

template<class Val >
void CH_Matrix_Classes::mat_xeya (Integer len, Val *x, const Val *y, const Val a)
Set x[i]=a*y[i] for len elements of the arrays x and y. More...

template<class Val >
void CH_Matrix_Classes::mat_xeya (Integer len, Val *x, const Integer incx, const Val *y, const Integer incy, const Val a)
Set x[i]=a*y[i] for len elements of the arrays x and y incremented by incx and incy, respectively. More...

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. More...

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. More...

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. More...

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! More...

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. More...

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! More...

template<class Val >
void CH_Matrix_Classes::mat_xpeya (Integer len, Val *x, const Val *y, const Val a)
Set x[i]+=a*y[i] for len elements of the arrays x and y. More...

template<class Val >
void CH_Matrix_Classes::mat_xpeya (Integer len, Val *x, const Integer incx, const Val *y, const Integer incy, const Val a)
Set x[i]+=a*y[i] for len elements of the arrays x and y incremented by incx and incy, respectively. More...

template<class Val >
void CH_Matrix_Classes::mat_xbpeya (Integer len, Val *x, const Val *y, const Val a, const Val b)
Set x[i]=a*y[i]+b*x[i] for len elements of the arrays x and y. More...

template<class Val >
void CH_Matrix_Classes::mat_xbpeya (Integer len, Val *x, const Integer incx, const Val *y, const Integer incy, const Val a, const 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. More...

template<class Val >
void CH_Matrix_Classes::mat_xpea (Integer len, Val *x, const Val a)
Set x[i]+=a for len elements of the array x. More...

template<class Val >
void CH_Matrix_Classes::mat_xpea (Integer len, Val *x, const Integer incx, const Val a)
Set x[i]+=a for len elements of the array x incremented by incx. More...

template<class Val >
void CH_Matrix_Classes::mat_xmultea (Integer len, Val *x, const Val a)
Set x[i]*=a for len elements of the array x. More...

template<class Val >
void CH_Matrix_Classes::mat_xmultea (Integer len, Val *x, const Integer incx, const Val a)
Set x[i]*=a for len elements of the array x incremented by incx. More...

template<class Val >
void CH_Matrix_Classes::mat_xdivea (Integer len, Val *x, const Val a)
Set x[i]/=a for len elements of the array x. More...

template<class Val >
void CH_Matrix_Classes::mat_xdivea (Integer len, Val *x, const Integer incx, const Val a)
Set x[i]/=a for len elements of the array x incremented by incx. More...

template<class Val >
void CH_Matrix_Classes::mat_xmodea (Integer len, Val *x, const Val a)
Set x[i]%=a for len elements of the array x. More...

template<class Val >
void CH_Matrix_Classes::mat_xmodea (Integer len, Val *x, const Integer incx, const Val a)
Set x[i]%=a for len elements of the array x incremented by incx. More...

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. More...

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. More...

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. More...

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. More...

template<class Val >
void CH_Matrix_Classes::mat_xeyapzb (Integer len, Val *x, const Val *y, const Val *z, const Val a, const Val b)
Set x[i]=a*y[i]+b*z[i] for len elements of the arrays x, y and z. More...

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, const Val a, const 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. More...

template<class Val >
Val CH_Matrix_Classes::mat_ip (Integer len, const Val *x, const Val *y, const Val *d=0)
return sum(x[i]*y[i]) summing over len elements of the arrays x and y. More...

template<class Val >
Val CH_Matrix_Classes::mat_ip (Integer len, const Val *x, const Integer incx, const Val *y, const Integer incy, const Val *d=0, const Integer incd=1)
return sum(x[i]*y[i]) summing over len elements of the arrays x and y incremented by incx and incy, respectively. More...

template<class Val >
Val CH_Matrix_Classes::mat_ip_dense_sparse (const Integer lenx, const Val *x, Integer leny, const Val *yval, const Integer *yind, const Val *d=0)
return sum(x[yind[j]]*yval[j]) summing over elements of the dense array x and a sparse array representation of y. More...

template<class Val >
Val CH_Matrix_Classes::mat_ip_sparse_sparse (const Integer lenx, const Val *xval, const Integer *xind, const Integer leny, const Val *yval, const Integer *yind, const Val *d)
return sum(xval[i]*yval[j] for i,j with xind[i]==yind[j]) summing over elements of the sparse array representations of x and y. More...

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. More...

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. More...

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. More...

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. More...

template<class Val >
bool CH_Matrix_Classes::mat_equal (Integer len, const Val *x, const Val *y)
returns true if the elements of the arrays x and y are exactly equal. More...

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. More...

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. More...

## Detailed Description

templates for simple linear algebra routines like BLAS level 1.

## ◆ mat_equal()

template<class Val >
 bool CH_Matrix_Classes::mat_equal ( Integer len, const Val * x, const Val * y )
inline

returns true if the elements of the arrays x and y are exactly equal.

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 secibd array
Returns
true if x[i]=y[i], 0<=i<len

References CH_Matrix_Classes::mat_swap().

Referenced by CH_Matrix_Classes::equal(), and CH_Matrix_Classes::Indexmatrix::get_store().

## ◆ mat_ip() [1/4]

template<class Val >
 Val CH_Matrix_Classes::mat_ip ( Integer len, const Val * x, const Val * y, const Val * d = 0 )
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 d if !=0 points to the starting address of the d array for diangonal weights
Returns
sum_{i=0}^{len} x[i] * y[i] (* d[i])

References CH_Matrix_Classes::sum().

## ◆ mat_ip() [2/4]

template<class Val >
 Val CH_Matrix_Classes::mat_ip ( Integer len, const Val * x, const Integer incx, const Val * y, const Integer incy, const Val * d = 0, const Integer incd = 1 )
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 d if !=0 points to the starting address of the d array for diangonal weights incd gives the increment for d in each step
Returns
sum_{i=0}^{len} x[i*incx] * y[i*incy] (* d(i))

References CH_Matrix_Classes::sum().

## ◆ mat_ip() [3/4]

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]

References CH_Matrix_Classes::mat_ip(), and CH_Matrix_Classes::sum().

## ◆ mat_ip() [4/4]

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]

References CH_Matrix_Classes::sum().

## ◆ mat_ip_dense_sparse()

template<class Val >
 Val CH_Matrix_Classes::mat_ip_dense_sparse ( const Integer lenx, const Val * x, Integer leny, const Val * yval, const Integer * yind, const Val * d = 0 )
inline

return sum(x[yind[j]]*yval[j]) summing over elements of the dense array x and a sparse array representation of y.

Any elements outside the range of the other are considered 0.

Parameters
 lenx gives the number of elements of x x points to the starting address of the x array leny gives the number of nonzero elements of y yval points to the starting address of the nonzero value array of y yind points to the strating address of the nonzero index array of y (the indices are assumed to be in strictly increasing order) d if !=0 points to the starting address of the d array for diangonal weights
Returns References CH_Matrix_Classes::sum().

## ◆ mat_ip_sparse_sparse()

template<class Val >
 Val CH_Matrix_Classes::mat_ip_sparse_sparse ( const Integer lenx, const Val * xval, const Integer * xind, const Integer leny, const Val * yval, const Integer * yind, const Val * d )
inline

return sum(xval[i]*yval[j] for i,j with xind[i]==yind[j]) summing over elements of the sparse array representations of x and y.

Any elements outside the range of the other are considered 0.

Parameters
 lenx gives the number of nonzero elements of x xval points to the starting address of the nonzero value arra of x xind points to the strating address of the nonzero index array of x (the indices are assumed to be in strictly increasing order) leny gives the number of nonzero elements of y yval points to the starting address of the nonzero value array of y yind points to the starting address of the nonzero index array of y (the indices are assumed to be in strictly increasing order) d if !=0 points to the starting address of the d array for diangonal weights
Returns where References CH_Matrix_Classes::mat_ip(), and CH_Matrix_Classes::sum().

## ◆ mat_sum() [1/2]

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]

References CH_Matrix_Classes::sum().

## ◆ mat_sum() [2/2]

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]

References CH_Matrix_Classes::sum().

## ◆ mat_swap() [1/2]

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

Referenced by CH_Matrix_Classes::mat_equal().

## ◆ mat_swap() [2/2]

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

## ◆ mat_xbpeya() [1/2]

template<class Val >
 void CH_Matrix_Classes::mat_xbpeya ( Integer len, Val * x, const Val * y, const Val a, const 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

Referenced by CH_Matrix_Classes::mat_xpeya(), and CH_Matrix_Classes::xbpeya().

## ◆ mat_xbpeya() [2/2]

template<class Val >
 void CH_Matrix_Classes::mat_xbpeya ( Integer len, Val * x, const Integer incx, const Val * y, const Integer incy, const Val a, const 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

## ◆ mat_xdivea() [1/2]

template<class Val >
 void CH_Matrix_Classes::mat_xdivea ( Integer len, Val * x, const 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)

Referenced by CH_Matrix_Classes::Indexmatrix::get_store(), and CH_Matrix_Classes::mat_xmultea().

## ◆ mat_xdivea() [2/2]

template<class Val >
 void CH_Matrix_Classes::mat_xdivea ( Integer len, Val * x, const Integer incx, const 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)

## ◆ mat_xea() [1/2]

template<class Val >
 void CH_Matrix_Classes::mat_xea ( Integer len, Val * x, const 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

## ◆ mat_xea() [2/2]

template<class Val >
 void CH_Matrix_Classes::mat_xea ( Integer len, Val * x, const Integer incx, const 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

References CH_Matrix_Classes::mat_xey().

## ◆ mat_xemx() [1/2]

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

Referenced by CH_Matrix_Classes::mat_xmey().

## ◆ mat_xemx() [2/2]

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

References CH_Matrix_Classes::mat_xemy().

## ◆ mat_xemy() [1/2]

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

Referenced by CH_Matrix_Classes::mat_xemx(), and CH_Matrix_Classes::mat_xeya().

## ◆ mat_xemy() [2/2]

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

References CH_Matrix_Classes::mat_xeya().

## ◆ mat_xey() [1/2]

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

## ◆ mat_xey() [2/2]

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

References CH_Matrix_Classes::mat_xmey().

## ◆ mat_xeya() [1/2]

template<class Val >
 void CH_Matrix_Classes::mat_xeya ( Integer len, Val * x, const Val * y, const 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

## ◆ mat_xeya() [2/2]

template<class Val >
 void CH_Matrix_Classes::mat_xeya ( Integer len, Val * x, const Integer incx, const Val * y, const Integer incy, const 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

## ◆ mat_xeyapzb() [1/2]

template<class Val >
 void CH_Matrix_Classes::mat_xeyapzb ( Integer len, Val * x, const Val * y, const Val * z, const Val a, const 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

Referenced by CH_Matrix_Classes::mat_xeymz(), and CH_Matrix_Classes::xeyapzb().

## ◆ mat_xeyapzb() [2/2]

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, const Val a, const 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

References CH_Matrix_Classes::mat_ip().

## ◆ mat_xeymz() [1/2]

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

Referenced by CH_Matrix_Classes::mat_xeypz().

## ◆ mat_xeymz() [2/2]

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

References CH_Matrix_Classes::mat_xeyapzb().

## ◆ mat_xeypz() [1/2]

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

Referenced by CH_Matrix_Classes::mat_xmodea().

## ◆ mat_xeypz() [2/2]

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

References CH_Matrix_Classes::mat_xeymz().

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

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_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_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

References CH_Matrix_Classes::mat_xpeya().

## ◆ mat_xmey() [1/2]

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

## ◆ mat_xmey() [2/2]

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

References CH_Matrix_Classes::mat_xemx().

## ◆ mat_xmodea() [1/2]

template<class Val >
 void CH_Matrix_Classes::mat_xmodea ( Integer len, Val * x, const 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)

Referenced by CH_Matrix_Classes::Indexmatrix::get_store().

## ◆ mat_xmodea() [2/2]

template<class Val >
 void CH_Matrix_Classes::mat_xmodea ( Integer len, Val * x, const Integer incx, const 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)

References CH_Matrix_Classes::mat_xeypz().

## ◆ mat_xmultea() [1/2]

template<class Val >
 void CH_Matrix_Classes::mat_xmultea ( Integer len, Val * x, const 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

## ◆ mat_xmultea() [2/2]

template<class Val >
 void CH_Matrix_Classes::mat_xmultea ( Integer len, Val * x, const Integer incx, const 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

References CH_Matrix_Classes::mat_xdivea().

## ◆ mat_xpea() [1/2]

template<class Val >
 void CH_Matrix_Classes::mat_xpea ( Integer len, Val * x, const 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

## ◆ mat_xpea() [2/2]

template<class Val >
 void CH_Matrix_Classes::mat_xpea ( Integer len, Val * x, const Integer incx, const 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

References CH_Matrix_Classes::mat_xmultea().

## ◆ mat_xpey() [1/2]

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

Referenced by CH_Matrix_Classes::mat_xeya(), and CH_Matrix_Classes::mat_xpeya().

## ◆ mat_xpey() [2/2]

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

## ◆ mat_xpeya() [1/2]

template<class Val >
 void CH_Matrix_Classes::mat_xpeya ( Integer len, Val * x, const Val * y, const 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

References CH_Matrix_Classes::mat_xmey(), and CH_Matrix_Classes::mat_xpey().

## ◆ mat_xpeya() [2/2]

template<class Val >
 void CH_Matrix_Classes::mat_xpeya ( Integer len, Val * x, const Integer incx, const Val * y, const Integer incy, const 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