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]=ay[i]+bx[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]=ay[i]+bx[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]=ay[i]+bz[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]=ay[i]+bz[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.

Function Documentation

◆ 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().

Referenced by ConicBundle::CMsymdense::add_projection(), ConicBundle::CMgramdense::add_projection(), ConicBundle::CMlowrankdd::add_projection(), ConicBundle::CMlowranksd::add_projection(), CH_Matrix_Classes::colip(), CH_Matrix_Classes::Indexmatrix::get_store(), ConicBundle::CMsymdense::gramip(), ConicBundle::CMlowrankss::gramip(), ConicBundle::CMsingleton::gramip(), ConicBundle::CMlowranksd::gramip(), ConicBundle::CMsymsparse::gramip(), ConicBundle::CMlowrankdd::gramip(), ConicBundle::CMgramsparse::gramip(), ConicBundle::CMgramdense::gramip(), ConicBundle::CMgramsparse_withoutdiag::gramip(), CH_Matrix_Classes::ip(), CH_Matrix_Classes::mat_ip(), CH_Matrix_Classes::mat_ip_sparse_sparse(), CH_Matrix_Classes::mat_xeyapzb(), CH_Matrix_Classes::norm2(), ConicBundle::CMlowrankdd::operator()(), ConicBundle::CMgramdense::operator()(), and CH_Matrix_Classes::rowip().

◆ 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: $sum_{i=0}^{leny} x[i[indy[j]] * y[i] (* d[i[indy[j]])$

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: $sum_{(i,j)\in J}xval[i] * yval[j] (* d[xind[i]])$ where $J=\{(i,j)\colon xind[i]=yind[j],i=1,\dots,lenx,j=1,\dots,leny\}$

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

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

◆ 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

Referenced by CH_Matrix_Classes::Indexmatrix::get_store(), ConicBundle::NNCIPBlock::get_vecdx(), ConicBundle::PSCIPBlock::get_vecdx(), ConicBundle::SOCIPBlock::get_vecdx(), ConicBundle::BoxIPBundleBlock::get_vecdx(), ConicBundle::NNCIPBlock::get_vecdz(), ConicBundle::PSCIPBlock::get_vecdz(), ConicBundle::SOCIPBlock::get_vecdz(), ConicBundle::BoxIPBundleBlock::get_vecdz(), ConicBundle::NNCIPBlock::get_vecx(), ConicBundle::PSCIPBlock::get_vecx(), ConicBundle::SOCIPBlock::get_vecx(), ConicBundle::BoxIPBundleBlock::get_vecx(), ConicBundle::NNCIPBlock::get_vecz(), ConicBundle::PSCIPBlock::get_vecz(), ConicBundle::SOCIPBlock::get_vecz(), ConicBundle::BoxIPBundleBlock::get_vecz(), CH_Matrix_Classes::Symmatrix::init(), CH_Matrix_Classes::Matrix::init(), CH_Matrix_Classes::Matrix::init_diag(), CH_Matrix_Classes::mat_xea(), and CH_Matrix_Classes::mat_xeya().

◆ 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

References CH_Matrix_Classes::mat_xea(), CH_Matrix_Classes::mat_xemy(), and CH_Matrix_Classes::mat_xey().

Referenced by CH_Matrix_Classes::Matrix::init(), CH_Matrix_Classes::Matrix::init_diag(), and CH_Matrix_Classes::mat_xemy().

◆ 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

References CH_Matrix_Classes::mat_xea(), CH_Matrix_Classes::mat_xemy(), CH_Matrix_Classes::mat_xey(), and CH_Matrix_Classes::mat_xpey().

◆ 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().

◆ mat_xhadey() [1/2]

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::Indexmatrix::get_store(), CH_Matrix_Classes::Symmatrix::operator%=(), and CH_Matrix_Classes::Matrix::operator%=().

◆ mat_xhadey() [2/2]

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

◆ mat_xinvhadey() [1/2]

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/=().

◆ mat_xinvhadey() [2/2]

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

Referenced by ConicBundle::BoxIPBundleBlock::get_vecdz(), ConicBundle::BoxIPBundleBlock::get_vecz(), CH_Matrix_Classes::mat_xey(), and CH_Matrix_Classes::mat_xpeya().

◆ 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

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

◆ 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

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

◆ 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().

Referenced by ConicBundle::CMsymdense::add_projection(), ConicBundle::CMgramsparse::add_projection(), ConicBundle::CMlowrankss::add_projection(), ConicBundle::CMlowranksd::add_projection(), ConicBundle::CMsymsparse::add_projection(), ConicBundle::CMgramsparse_withoutdiag::add_projection(), ConicBundle::CMsingleton::addprodto(), ConicBundle::CMsymdense::gramip(), ConicBundle::CMlowrankss::gramip(), ConicBundle::CMlowranksd::gramip(), ConicBundle::CMsymsparse::gramip(), ConicBundle::CMgramsparse::gramip(), ConicBundle::CMgramsparse_withoutdiag::gramip(), and CH_Matrix_Classes::mat_xinvhadey().

◆ 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

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

Functions

Detailed Description

Function Documentation

◆ mat_equal()

◆ mat_ip() [1/4]

◆ mat_ip() [2/4]

◆ mat_ip() [3/4]

◆ mat_ip() [4/4]

◆ mat_ip_dense_sparse()

◆ mat_ip_sparse_sparse()

◆ mat_sum() [1/2]

◆ mat_sum() [2/2]

◆ mat_swap() [1/2]

◆ mat_swap() [2/2]

◆ mat_xbpeya() [1/2]

◆ mat_xbpeya() [2/2]

◆ mat_xdivea() [1/2]

◆ mat_xdivea() [2/2]

◆ mat_xea() [1/2]

◆ mat_xea() [2/2]

◆ mat_xemx() [1/2]

◆ mat_xemx() [2/2]

◆ mat_xemy() [1/2]

◆ mat_xemy() [2/2]

◆ mat_xey() [1/2]

◆ mat_xey() [2/2]

◆ mat_xeya() [1/2]

◆ mat_xeya() [2/2]

◆ mat_xeyapzb() [1/2]

◆ mat_xeyapzb() [2/2]

◆ mat_xeymz() [1/2]

◆ mat_xeymz() [2/2]

◆ mat_xeypz() [1/2]

◆ mat_xeypz() [2/2]

◆ mat_xhadey() [1/2]

◆ mat_xhadey() [2/2]

◆ mat_xinvhadey() [1/2]

◆ mat_xinvhadey() [2/2]

◆ mat_xmey() [1/2]

◆ mat_xmey() [2/2]

◆ mat_xmodea() [1/2]

◆ mat_xmodea() [2/2]

◆ mat_xmultea() [1/2]

◆ mat_xmultea() [2/2]

◆ mat_xpea() [1/2]

◆ mat_xpea() [2/2]

◆ mat_xpey() [1/2]

◆ mat_xpey() [2/2]

◆ mat_xpeya() [1/2]

◆ mat_xpeya() [2/2]