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. |
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.
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 |
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.
len | gives the number of elements to be processed | |
x | points to the starting address of the array |
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.
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 |
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.
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 |
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.
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 |
Val CH_Matrix_Classes::mat_sum | ( | Integer | len, | |
const Val * | x | |||
) | [inline] |
returns sum(x[i]) over len elements of the array x.
len | gives the number of elements to be processed | |
x | points to the starting address of the first array |
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.
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 |
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.
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 |
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.
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 |
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.
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 |
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.
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) |
void CH_Matrix_Classes::mat_xdivea | ( | Integer | len, | |
Val * | x, | |||
Val | a | |||
) | [inline] |
Set x[i]/=a for len elements of the array x.
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) |
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.
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 |
void CH_Matrix_Classes::mat_xea | ( | Integer | len, | |
Val * | x, | |||
Val | a | |||
) | [inline] |
Set x[i]=a for len elements of the array x.
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().
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.
len | gives the number of elements | |
x | points to the starting address | |
incx | gives the increment for x in each step |
void CH_Matrix_Classes::mat_xemx | ( | Integer | len, | |
Val * | x | |||
) | [inline] |
Set x[i]=-x[i] for an array of length len.
len | gives the number of elements | |
x | points to the starting address |
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.
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 |
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.
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 |
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).
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 |
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.
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().
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.
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 |
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.
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 |
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.
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 |
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.
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 |
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.
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 |
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.
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 |
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.
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 |
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.
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 |
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.
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 |
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.
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%=().
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!
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 |
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!
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/=().
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.
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 |
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.
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 |
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.
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) |
void CH_Matrix_Classes::mat_xmodea | ( | Integer | len, | |
Val * | x, | |||
Val | a | |||
) | [inline] |
Set x[i]=a for len elements of the array x.
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) |
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.
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 |
void CH_Matrix_Classes::mat_xmultea | ( | Integer | len, | |
Val * | x, | |||
Val | a | |||
) | [inline] |
Set x[i]*=a for len elements of the array x.
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/=().
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.
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 |
void CH_Matrix_Classes::mat_xpea | ( | Integer | len, | |
Val * | x, | |||
Val | a | |||
) | [inline] |
Set x[i]+=a for len elements of the array x.
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-=().
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.
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 |
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.
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 |
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.
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 |
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.
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 |