la_norms::get_norm Interface Reference

Vector norm: subroutine interface. More...

Public Member Functions
pure subroutine	norm_1d_char_s (a, nrm, order, err)
pure subroutine	norm_2d_char_s (a, nrm, order, err)
pure subroutine	norm_3d_char_s (a, nrm, order, err)
pure subroutine	norm_4d_char_s (a, nrm, order, err)
pure subroutine	norm_5d_char_s (a, nrm, order, err)
pure subroutine	norm_6d_char_s (a, nrm, order, err)
pure subroutine	norm_7d_char_s (a, nrm, order, err)
pure subroutine	norm_2d_to_1d_char_s (a, nrm, order, dim, err)
pure subroutine	norm_3d_to_2d_char_s (a, nrm, order, dim, err)
pure subroutine	norm_4d_to_3d_char_s (a, nrm, order, dim, err)
pure subroutine	norm_5d_to_4d_char_s (a, nrm, order, dim, err)
pure subroutine	norm_6d_to_5d_char_s (a, nrm, order, dim, err)
pure subroutine	norm_7d_to_6d_char_s (a, nrm, order, dim, err)
pure subroutine	norm_1d_int_s (a, nrm, order, err)
pure subroutine	norm_2d_int_s (a, nrm, order, err)
pure subroutine	norm_3d_int_s (a, nrm, order, err)
pure subroutine	norm_4d_int_s (a, nrm, order, err)
pure subroutine	norm_5d_int_s (a, nrm, order, err)
pure subroutine	norm_6d_int_s (a, nrm, order, err)
pure subroutine	norm_7d_int_s (a, nrm, order, err)
pure subroutine	norm_2d_to_1d_int_s (a, nrm, order, dim, err)
pure subroutine	norm_3d_to_2d_int_s (a, nrm, order, dim, err)
pure subroutine	norm_4d_to_3d_int_s (a, nrm, order, dim, err)
pure subroutine	norm_5d_to_4d_int_s (a, nrm, order, dim, err)
pure subroutine	norm_6d_to_5d_int_s (a, nrm, order, dim, err)
pure subroutine	norm_7d_to_6d_int_s (a, nrm, order, dim, err)
pure subroutine	norm_1d_char_d (a, nrm, order, err)
pure subroutine	norm_2d_char_d (a, nrm, order, err)
pure subroutine	norm_3d_char_d (a, nrm, order, err)
pure subroutine	norm_4d_char_d (a, nrm, order, err)
pure subroutine	norm_5d_char_d (a, nrm, order, err)
pure subroutine	norm_6d_char_d (a, nrm, order, err)
pure subroutine	norm_7d_char_d (a, nrm, order, err)
pure subroutine	norm_2d_to_1d_char_d (a, nrm, order, dim, err)
pure subroutine	norm_3d_to_2d_char_d (a, nrm, order, dim, err)
pure subroutine	norm_4d_to_3d_char_d (a, nrm, order, dim, err)
pure subroutine	norm_5d_to_4d_char_d (a, nrm, order, dim, err)
pure subroutine	norm_6d_to_5d_char_d (a, nrm, order, dim, err)
pure subroutine	norm_7d_to_6d_char_d (a, nrm, order, dim, err)
pure subroutine	norm_1d_int_d (a, nrm, order, err)
pure subroutine	norm_2d_int_d (a, nrm, order, err)
pure subroutine	norm_3d_int_d (a, nrm, order, err)
pure subroutine	norm_4d_int_d (a, nrm, order, err)
pure subroutine	norm_5d_int_d (a, nrm, order, err)
pure subroutine	norm_6d_int_d (a, nrm, order, err)
pure subroutine	norm_7d_int_d (a, nrm, order, err)
pure subroutine	norm_2d_to_1d_int_d (a, nrm, order, dim, err)
pure subroutine	norm_3d_to_2d_int_d (a, nrm, order, dim, err)
pure subroutine	norm_4d_to_3d_int_d (a, nrm, order, dim, err)
pure subroutine	norm_5d_to_4d_int_d (a, nrm, order, dim, err)
pure subroutine	norm_6d_to_5d_int_d (a, nrm, order, dim, err)
pure subroutine	norm_7d_to_6d_int_d (a, nrm, order, dim, err)
pure subroutine	norm_1d_char_q (a, nrm, order, err)
pure subroutine	norm_2d_char_q (a, nrm, order, err)
pure subroutine	norm_3d_char_q (a, nrm, order, err)
pure subroutine	norm_4d_char_q (a, nrm, order, err)
pure subroutine	norm_5d_char_q (a, nrm, order, err)
pure subroutine	norm_6d_char_q (a, nrm, order, err)
pure subroutine	norm_7d_char_q (a, nrm, order, err)
pure subroutine	norm_2d_to_1d_char_q (a, nrm, order, dim, err)
pure subroutine	norm_3d_to_2d_char_q (a, nrm, order, dim, err)
pure subroutine	norm_4d_to_3d_char_q (a, nrm, order, dim, err)
pure subroutine	norm_5d_to_4d_char_q (a, nrm, order, dim, err)
pure subroutine	norm_6d_to_5d_char_q (a, nrm, order, dim, err)
pure subroutine	norm_7d_to_6d_char_q (a, nrm, order, dim, err)
pure subroutine	norm_1d_int_q (a, nrm, order, err)
pure subroutine	norm_2d_int_q (a, nrm, order, err)
pure subroutine	norm_3d_int_q (a, nrm, order, err)
pure subroutine	norm_4d_int_q (a, nrm, order, err)
pure subroutine	norm_5d_int_q (a, nrm, order, err)
pure subroutine	norm_6d_int_q (a, nrm, order, err)
pure subroutine	norm_7d_int_q (a, nrm, order, err)
pure subroutine	norm_2d_to_1d_int_q (a, nrm, order, dim, err)
pure subroutine	norm_3d_to_2d_int_q (a, nrm, order, dim, err)
pure subroutine	norm_4d_to_3d_int_q (a, nrm, order, dim, err)
pure subroutine	norm_5d_to_4d_int_q (a, nrm, order, dim, err)
pure subroutine	norm_6d_to_5d_int_q (a, nrm, order, dim, err)
pure subroutine	norm_7d_to_6d_int_q (a, nrm, order, dim, err)
pure subroutine	norm_1d_char_c (a, nrm, order, err)
pure subroutine	norm_2d_char_c (a, nrm, order, err)
pure subroutine	norm_3d_char_c (a, nrm, order, err)
pure subroutine	norm_4d_char_c (a, nrm, order, err)
pure subroutine	norm_5d_char_c (a, nrm, order, err)
pure subroutine	norm_6d_char_c (a, nrm, order, err)
pure subroutine	norm_7d_char_c (a, nrm, order, err)
pure subroutine	norm_2d_to_1d_char_c (a, nrm, order, dim, err)
pure subroutine	norm_3d_to_2d_char_c (a, nrm, order, dim, err)
pure subroutine	norm_4d_to_3d_char_c (a, nrm, order, dim, err)
pure subroutine	norm_5d_to_4d_char_c (a, nrm, order, dim, err)
pure subroutine	norm_6d_to_5d_char_c (a, nrm, order, dim, err)
pure subroutine	norm_7d_to_6d_char_c (a, nrm, order, dim, err)
pure subroutine	norm_1d_int_c (a, nrm, order, err)
pure subroutine	norm_2d_int_c (a, nrm, order, err)
pure subroutine	norm_3d_int_c (a, nrm, order, err)
pure subroutine	norm_4d_int_c (a, nrm, order, err)
pure subroutine	norm_5d_int_c (a, nrm, order, err)
pure subroutine	norm_6d_int_c (a, nrm, order, err)
pure subroutine	norm_7d_int_c (a, nrm, order, err)
pure subroutine	norm_2d_to_1d_int_c (a, nrm, order, dim, err)
pure subroutine	norm_3d_to_2d_int_c (a, nrm, order, dim, err)
pure subroutine	norm_4d_to_3d_int_c (a, nrm, order, dim, err)
pure subroutine	norm_5d_to_4d_int_c (a, nrm, order, dim, err)
pure subroutine	norm_6d_to_5d_int_c (a, nrm, order, dim, err)
pure subroutine	norm_7d_to_6d_int_c (a, nrm, order, dim, err)
pure subroutine	norm_1d_char_z (a, nrm, order, err)
pure subroutine	norm_2d_char_z (a, nrm, order, err)
pure subroutine	norm_3d_char_z (a, nrm, order, err)
pure subroutine	norm_4d_char_z (a, nrm, order, err)
pure subroutine	norm_5d_char_z (a, nrm, order, err)
pure subroutine	norm_6d_char_z (a, nrm, order, err)
pure subroutine	norm_7d_char_z (a, nrm, order, err)
pure subroutine	norm_2d_to_1d_char_z (a, nrm, order, dim, err)
pure subroutine	norm_3d_to_2d_char_z (a, nrm, order, dim, err)
pure subroutine	norm_4d_to_3d_char_z (a, nrm, order, dim, err)
pure subroutine	norm_5d_to_4d_char_z (a, nrm, order, dim, err)
pure subroutine	norm_6d_to_5d_char_z (a, nrm, order, dim, err)
pure subroutine	norm_7d_to_6d_char_z (a, nrm, order, dim, err)
pure subroutine	norm_1d_int_z (a, nrm, order, err)
pure subroutine	norm_2d_int_z (a, nrm, order, err)
pure subroutine	norm_3d_int_z (a, nrm, order, err)
pure subroutine	norm_4d_int_z (a, nrm, order, err)
pure subroutine	norm_5d_int_z (a, nrm, order, err)
pure subroutine	norm_6d_int_z (a, nrm, order, err)
pure subroutine	norm_7d_int_z (a, nrm, order, err)
pure subroutine	norm_2d_to_1d_int_z (a, nrm, order, dim, err)
pure subroutine	norm_3d_to_2d_int_z (a, nrm, order, dim, err)
pure subroutine	norm_4d_to_3d_int_z (a, nrm, order, dim, err)
pure subroutine	norm_5d_to_4d_int_z (a, nrm, order, dim, err)
pure subroutine	norm_6d_to_5d_int_z (a, nrm, order, dim, err)
pure subroutine	norm_7d_to_6d_int_z (a, nrm, order, dim, err)
pure subroutine	norm_1d_char_w (a, nrm, order, err)
pure subroutine	norm_2d_char_w (a, nrm, order, err)
pure subroutine	norm_3d_char_w (a, nrm, order, err)
pure subroutine	norm_4d_char_w (a, nrm, order, err)
pure subroutine	norm_5d_char_w (a, nrm, order, err)
pure subroutine	norm_6d_char_w (a, nrm, order, err)
pure subroutine	norm_7d_char_w (a, nrm, order, err)
pure subroutine	norm_2d_to_1d_char_w (a, nrm, order, dim, err)
pure subroutine	norm_3d_to_2d_char_w (a, nrm, order, dim, err)
pure subroutine	norm_4d_to_3d_char_w (a, nrm, order, dim, err)
pure subroutine	norm_5d_to_4d_char_w (a, nrm, order, dim, err)
pure subroutine	norm_6d_to_5d_char_w (a, nrm, order, dim, err)
pure subroutine	norm_7d_to_6d_char_w (a, nrm, order, dim, err)
pure subroutine	norm_1d_int_w (a, nrm, order, err)
pure subroutine	norm_2d_int_w (a, nrm, order, err)
pure subroutine	norm_3d_int_w (a, nrm, order, err)
pure subroutine	norm_4d_int_w (a, nrm, order, err)
pure subroutine	norm_5d_int_w (a, nrm, order, err)
pure subroutine	norm_6d_int_w (a, nrm, order, err)
pure subroutine	norm_7d_int_w (a, nrm, order, err)
pure subroutine	norm_2d_to_1d_int_w (a, nrm, order, dim, err)
pure subroutine	norm_3d_to_2d_int_w (a, nrm, order, dim, err)
pure subroutine	norm_4d_to_3d_int_w (a, nrm, order, dim, err)
pure subroutine	norm_5d_to_4d_int_w (a, nrm, order, dim, err)
pure subroutine	norm_6d_to_5d_int_w (a, nrm, order, dim, err)
pure subroutine	norm_7d_to_6d_int_w (a, nrm, order, dim, err)

Detailed Description

Vector norm: subroutine interface.

Member Function/Subroutine Documentation

norm_1d_char_c()

pure subroutine la_norms::get_norm::norm_1d_char_c	(	complex(sp), dimension(:), intent(in)	a,
		real(sp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 1-d matrix a(:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_1d_char_d()

pure subroutine la_norms::get_norm::norm_1d_char_d	(	real(dp), dimension(:), intent(in)	a,
		real(dp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 1-d matrix a(:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_1d_char_q()

pure subroutine la_norms::get_norm::norm_1d_char_q	(	real(qp), dimension(:), intent(in)	a,
		real(qp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 1-d matrix a(:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_1d_char_s()

pure subroutine la_norms::get_norm::norm_1d_char_s	(	real(sp), dimension(:), intent(in)	a,
		real(sp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 1-d matrix a(:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_1d_char_w()

pure subroutine la_norms::get_norm::norm_1d_char_w	(	complex(qp), dimension(:), intent(in)	a,
		real(qp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 1-d matrix a(:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_1d_char_z()

pure subroutine la_norms::get_norm::norm_1d_char_z	(	complex(dp), dimension(:), intent(in)	a,
		real(dp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 1-d matrix a(:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_1d_int_c()

pure subroutine la_norms::get_norm::norm_1d_int_c	(	complex(sp), dimension(:), intent(in)	a,
		real(sp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 1-d matrix a(:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_1d_int_d()

pure subroutine la_norms::get_norm::norm_1d_int_d	(	real(dp), dimension(:), intent(in)	a,
		real(dp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 1-d matrix a(:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_1d_int_q()

pure subroutine la_norms::get_norm::norm_1d_int_q	(	real(qp), dimension(:), intent(in)	a,
		real(qp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 1-d matrix a(:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_1d_int_s()

pure subroutine la_norms::get_norm::norm_1d_int_s	(	real(sp), dimension(:), intent(in)	a,
		real(sp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 1-d matrix a(:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_1d_int_w()

pure subroutine la_norms::get_norm::norm_1d_int_w	(	complex(qp), dimension(:), intent(in)	a,
		real(qp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 1-d matrix a(:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_1d_int_z()

pure subroutine la_norms::get_norm::norm_1d_int_z	(	complex(dp), dimension(:), intent(in)	a,
		real(dp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 1-d matrix a(:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_2d_char_c()

pure subroutine la_norms::get_norm::norm_2d_char_c	(	complex(sp), dimension(:,:), intent(in)	a,
		real(sp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 2-d matrix a(:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_2d_char_d()

pure subroutine la_norms::get_norm::norm_2d_char_d	(	real(dp), dimension(:,:), intent(in)	a,
		real(dp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 2-d matrix a(:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_2d_char_q()

pure subroutine la_norms::get_norm::norm_2d_char_q	(	real(qp), dimension(:,:), intent(in)	a,
		real(qp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 2-d matrix a(:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_2d_char_s()

pure subroutine la_norms::get_norm::norm_2d_char_s	(	real(sp), dimension(:,:), intent(in)	a,
		real(sp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 2-d matrix a(:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_2d_char_w()

pure subroutine la_norms::get_norm::norm_2d_char_w	(	complex(qp), dimension(:,:), intent(in)	a,
		real(qp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 2-d matrix a(:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_2d_char_z()

pure subroutine la_norms::get_norm::norm_2d_char_z	(	complex(dp), dimension(:,:), intent(in)	a,
		real(dp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 2-d matrix a(:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_2d_int_c()

pure subroutine la_norms::get_norm::norm_2d_int_c	(	complex(sp), dimension(:,:), intent(in)	a,
		real(sp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 2-d matrix a(:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_2d_int_d()

pure subroutine la_norms::get_norm::norm_2d_int_d	(	real(dp), dimension(:,:), intent(in)	a,
		real(dp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 2-d matrix a(:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_2d_int_q()

pure subroutine la_norms::get_norm::norm_2d_int_q	(	real(qp), dimension(:,:), intent(in)	a,
		real(qp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 2-d matrix a(:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_2d_int_s()

pure subroutine la_norms::get_norm::norm_2d_int_s	(	real(sp), dimension(:,:), intent(in)	a,
		real(sp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 2-d matrix a(:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_2d_int_w()

pure subroutine la_norms::get_norm::norm_2d_int_w	(	complex(qp), dimension(:,:), intent(in)	a,
		real(qp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 2-d matrix a(:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_2d_int_z()

pure subroutine la_norms::get_norm::norm_2d_int_z	(	complex(dp), dimension(:,:), intent(in)	a,
		real(dp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 2-d matrix a(:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_2d_to_1d_char_c()

pure subroutine la_norms::get_norm::norm_2d_to_1d_char_c	(	complex(sp), dimension(:,:), intent(in), target	a,
		real(sp), dimension(merge(size(a,1),size(a,2),mask=1 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_2d_to_1d_char_d()

pure subroutine la_norms::get_norm::norm_2d_to_1d_char_d	(	real(dp), dimension(:,:), intent(in), target	a,
		real(dp), dimension(merge(size(a,1),size(a,2),mask=1 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_2d_to_1d_char_q()

pure subroutine la_norms::get_norm::norm_2d_to_1d_char_q	(	real(qp), dimension(:,:), intent(in), target	a,
		real(qp), dimension(merge(size(a,1),size(a,2),mask=1 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_2d_to_1d_char_s()

pure subroutine la_norms::get_norm::norm_2d_to_1d_char_s	(	real(sp), dimension(:,:), intent(in), target	a,
		real(sp), dimension(merge(size(a,1),size(a,2),mask=1 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_2d_to_1d_char_w()

pure subroutine la_norms::get_norm::norm_2d_to_1d_char_w	(	complex(qp), dimension(:,:), intent(in), target	a,
		real(qp), dimension(merge(size(a,1),size(a,2),mask=1 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_2d_to_1d_char_z()

pure subroutine la_norms::get_norm::norm_2d_to_1d_char_z	(	complex(dp), dimension(:,:), intent(in), target	a,
		real(dp), dimension(merge(size(a,1),size(a,2),mask=1 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_2d_to_1d_int_c()

pure subroutine la_norms::get_norm::norm_2d_to_1d_int_c	(	complex(sp), dimension(:,:), intent(in), target	a,
		real(sp), dimension(merge(size(a,1),size(a,2),mask=1 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_2d_to_1d_int_d()

pure subroutine la_norms::get_norm::norm_2d_to_1d_int_d	(	real(dp), dimension(:,:), intent(in), target	a,
		real(dp), dimension(merge(size(a,1),size(a,2),mask=1 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_2d_to_1d_int_q()

pure subroutine la_norms::get_norm::norm_2d_to_1d_int_q	(	real(qp), dimension(:,:), intent(in), target	a,
		real(qp), dimension(merge(size(a,1),size(a,2),mask=1 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_2d_to_1d_int_s()

pure subroutine la_norms::get_norm::norm_2d_to_1d_int_s	(	real(sp), dimension(:,:), intent(in), target	a,
		real(sp), dimension(merge(size(a,1),size(a,2),mask=1 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_2d_to_1d_int_w()

pure subroutine la_norms::get_norm::norm_2d_to_1d_int_w	(	complex(qp), dimension(:,:), intent(in), target	a,
		real(qp), dimension(merge(size(a,1),size(a,2),mask=1 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_2d_to_1d_int_z()

pure subroutine la_norms::get_norm::norm_2d_to_1d_int_z	(	complex(dp), dimension(:,:), intent(in), target	a,
		real(dp), dimension(merge(size(a,1),size(a,2),mask=1 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_3d_char_c()

pure subroutine la_norms::get_norm::norm_3d_char_c	(	complex(sp), dimension(:,:,:), intent(in)	a,
		real(sp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 3-d matrix a(:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_3d_char_d()

pure subroutine la_norms::get_norm::norm_3d_char_d	(	real(dp), dimension(:,:,:), intent(in)	a,
		real(dp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 3-d matrix a(:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_3d_char_q()

pure subroutine la_norms::get_norm::norm_3d_char_q	(	real(qp), dimension(:,:,:), intent(in)	a,
		real(qp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 3-d matrix a(:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_3d_char_s()

pure subroutine la_norms::get_norm::norm_3d_char_s	(	real(sp), dimension(:,:,:), intent(in)	a,
		real(sp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 3-d matrix a(:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_3d_char_w()

pure subroutine la_norms::get_norm::norm_3d_char_w	(	complex(qp), dimension(:,:,:), intent(in)	a,
		real(qp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 3-d matrix a(:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_3d_char_z()

pure subroutine la_norms::get_norm::norm_3d_char_z	(	complex(dp), dimension(:,:,:), intent(in)	a,
		real(dp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 3-d matrix a(:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_3d_int_c()

pure subroutine la_norms::get_norm::norm_3d_int_c	(	complex(sp), dimension(:,:,:), intent(in)	a,
		real(sp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 3-d matrix a(:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_3d_int_d()

pure subroutine la_norms::get_norm::norm_3d_int_d	(	real(dp), dimension(:,:,:), intent(in)	a,
		real(dp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 3-d matrix a(:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_3d_int_q()

pure subroutine la_norms::get_norm::norm_3d_int_q	(	real(qp), dimension(:,:,:), intent(in)	a,
		real(qp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 3-d matrix a(:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_3d_int_s()

pure subroutine la_norms::get_norm::norm_3d_int_s	(	real(sp), dimension(:,:,:), intent(in)	a,
		real(sp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 3-d matrix a(:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_3d_int_w()

pure subroutine la_norms::get_norm::norm_3d_int_w	(	complex(qp), dimension(:,:,:), intent(in)	a,
		real(qp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 3-d matrix a(:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_3d_int_z()

pure subroutine la_norms::get_norm::norm_3d_int_z	(	complex(dp), dimension(:,:,:), intent(in)	a,
		real(dp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 3-d matrix a(:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_3d_to_2d_char_c()

pure subroutine la_norms::get_norm::norm_3d_to_2d_char_c	(	complex(sp), dimension(:,:,:), intent(in), target	a,
		real(sp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_3d_to_2d_char_d()

pure subroutine la_norms::get_norm::norm_3d_to_2d_char_d	(	real(dp), dimension(:,:,:), intent(in), target	a,
		real(dp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_3d_to_2d_char_q()

pure subroutine la_norms::get_norm::norm_3d_to_2d_char_q	(	real(qp), dimension(:,:,:), intent(in), target	a,
		real(qp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_3d_to_2d_char_s()

pure subroutine la_norms::get_norm::norm_3d_to_2d_char_s	(	real(sp), dimension(:,:,:), intent(in), target	a,
		real(sp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_3d_to_2d_char_w()

pure subroutine la_norms::get_norm::norm_3d_to_2d_char_w	(	complex(qp), dimension(:,:,:), intent(in), target	a,
		real(qp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_3d_to_2d_char_z()

pure subroutine la_norms::get_norm::norm_3d_to_2d_char_z	(	complex(dp), dimension(:,:,:), intent(in), target	a,
		real(dp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_3d_to_2d_int_c()

pure subroutine la_norms::get_norm::norm_3d_to_2d_int_c	(	complex(sp), dimension(:,:,:), intent(in), target	a,
		real(sp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_3d_to_2d_int_d()

pure subroutine la_norms::get_norm::norm_3d_to_2d_int_d	(	real(dp), dimension(:,:,:), intent(in), target	a,
		real(dp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_3d_to_2d_int_q()

pure subroutine la_norms::get_norm::norm_3d_to_2d_int_q	(	real(qp), dimension(:,:,:), intent(in), target	a,
		real(qp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_3d_to_2d_int_s()

pure subroutine la_norms::get_norm::norm_3d_to_2d_int_s	(	real(sp), dimension(:,:,:), intent(in), target	a,
		real(sp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_3d_to_2d_int_w()

pure subroutine la_norms::get_norm::norm_3d_to_2d_int_w	(	complex(qp), dimension(:,:,:), intent(in), target	a,
		real(qp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_3d_to_2d_int_z()

pure subroutine la_norms::get_norm::norm_3d_to_2d_int_z	(	complex(dp), dimension(:,:,:), intent(in), target	a,
		real(dp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_4d_char_c()

pure subroutine la_norms::get_norm::norm_4d_char_c	(	complex(sp), dimension(:,:,:,:), intent(in)	a,
		real(sp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 4-d matrix a(:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_4d_char_d()

pure subroutine la_norms::get_norm::norm_4d_char_d	(	real(dp), dimension(:,:,:,:), intent(in)	a,
		real(dp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 4-d matrix a(:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_4d_char_q()

pure subroutine la_norms::get_norm::norm_4d_char_q	(	real(qp), dimension(:,:,:,:), intent(in)	a,
		real(qp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 4-d matrix a(:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_4d_char_s()

pure subroutine la_norms::get_norm::norm_4d_char_s	(	real(sp), dimension(:,:,:,:), intent(in)	a,
		real(sp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 4-d matrix a(:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_4d_char_w()

pure subroutine la_norms::get_norm::norm_4d_char_w	(	complex(qp), dimension(:,:,:,:), intent(in)	a,
		real(qp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 4-d matrix a(:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_4d_char_z()

pure subroutine la_norms::get_norm::norm_4d_char_z	(	complex(dp), dimension(:,:,:,:), intent(in)	a,
		real(dp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 4-d matrix a(:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_4d_int_c()

pure subroutine la_norms::get_norm::norm_4d_int_c	(	complex(sp), dimension(:,:,:,:), intent(in)	a,
		real(sp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 4-d matrix a(:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_4d_int_d()

pure subroutine la_norms::get_norm::norm_4d_int_d	(	real(dp), dimension(:,:,:,:), intent(in)	a,
		real(dp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 4-d matrix a(:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_4d_int_q()

pure subroutine la_norms::get_norm::norm_4d_int_q	(	real(qp), dimension(:,:,:,:), intent(in)	a,
		real(qp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 4-d matrix a(:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_4d_int_s()

pure subroutine la_norms::get_norm::norm_4d_int_s	(	real(sp), dimension(:,:,:,:), intent(in)	a,
		real(sp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 4-d matrix a(:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_4d_int_w()

pure subroutine la_norms::get_norm::norm_4d_int_w	(	complex(qp), dimension(:,:,:,:), intent(in)	a,
		real(qp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 4-d matrix a(:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_4d_int_z()

pure subroutine la_norms::get_norm::norm_4d_int_z	(	complex(dp), dimension(:,:,:,:), intent(in)	a,
		real(dp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 4-d matrix a(:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_4d_to_3d_char_c()

pure subroutine la_norms::get_norm::norm_4d_to_3d_char_c	(	complex(sp), dimension(:,:,:,:), intent(in), target	a,
		real(sp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_4d_to_3d_char_d()

pure subroutine la_norms::get_norm::norm_4d_to_3d_char_d	(	real(dp), dimension(:,:,:,:), intent(in), target	a,
		real(dp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_4d_to_3d_char_q()

pure subroutine la_norms::get_norm::norm_4d_to_3d_char_q	(	real(qp), dimension(:,:,:,:), intent(in), target	a,
		real(qp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_4d_to_3d_char_s()

pure subroutine la_norms::get_norm::norm_4d_to_3d_char_s	(	real(sp), dimension(:,:,:,:), intent(in), target	a,
		real(sp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_4d_to_3d_char_w()

pure subroutine la_norms::get_norm::norm_4d_to_3d_char_w	(	complex(qp), dimension(:,:,:,:), intent(in), target	a,
		real(qp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_4d_to_3d_char_z()

pure subroutine la_norms::get_norm::norm_4d_to_3d_char_z	(	complex(dp), dimension(:,:,:,:), intent(in), target	a,
		real(dp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_4d_to_3d_int_c()

pure subroutine la_norms::get_norm::norm_4d_to_3d_int_c	(	complex(sp), dimension(:,:,:,:), intent(in), target	a,
		real(sp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_4d_to_3d_int_d()

pure subroutine la_norms::get_norm::norm_4d_to_3d_int_d	(	real(dp), dimension(:,:,:,:), intent(in), target	a,
		real(dp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_4d_to_3d_int_q()

pure subroutine la_norms::get_norm::norm_4d_to_3d_int_q	(	real(qp), dimension(:,:,:,:), intent(in), target	a,
		real(qp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_4d_to_3d_int_s()

pure subroutine la_norms::get_norm::norm_4d_to_3d_int_s	(	real(sp), dimension(:,:,:,:), intent(in), target	a,
		real(sp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_4d_to_3d_int_w()

pure subroutine la_norms::get_norm::norm_4d_to_3d_int_w	(	complex(qp), dimension(:,:,:,:), intent(in), target	a,
		real(qp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_4d_to_3d_int_z()

pure subroutine la_norms::get_norm::norm_4d_to_3d_int_z	(	complex(dp), dimension(:,:,:,:), intent(in), target	a,
		real(dp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_5d_char_c()

pure subroutine la_norms::get_norm::norm_5d_char_c	(	complex(sp), dimension(:,:,:,:,:), intent(in)	a,
		real(sp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 5-d matrix a(:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_5d_char_d()

pure subroutine la_norms::get_norm::norm_5d_char_d	(	real(dp), dimension(:,:,:,:,:), intent(in)	a,
		real(dp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 5-d matrix a(:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_5d_char_q()

pure subroutine la_norms::get_norm::norm_5d_char_q	(	real(qp), dimension(:,:,:,:,:), intent(in)	a,
		real(qp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 5-d matrix a(:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_5d_char_s()

pure subroutine la_norms::get_norm::norm_5d_char_s	(	real(sp), dimension(:,:,:,:,:), intent(in)	a,
		real(sp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 5-d matrix a(:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_5d_char_w()

pure subroutine la_norms::get_norm::norm_5d_char_w	(	complex(qp), dimension(:,:,:,:,:), intent(in)	a,
		real(qp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 5-d matrix a(:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_5d_char_z()

pure subroutine la_norms::get_norm::norm_5d_char_z	(	complex(dp), dimension(:,:,:,:,:), intent(in)	a,
		real(dp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 5-d matrix a(:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_5d_int_c()

pure subroutine la_norms::get_norm::norm_5d_int_c	(	complex(sp), dimension(:,:,:,:,:), intent(in)	a,
		real(sp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 5-d matrix a(:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_5d_int_d()

pure subroutine la_norms::get_norm::norm_5d_int_d	(	real(dp), dimension(:,:,:,:,:), intent(in)	a,
		real(dp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 5-d matrix a(:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_5d_int_q()

pure subroutine la_norms::get_norm::norm_5d_int_q	(	real(qp), dimension(:,:,:,:,:), intent(in)	a,
		real(qp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 5-d matrix a(:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_5d_int_s()

pure subroutine la_norms::get_norm::norm_5d_int_s	(	real(sp), dimension(:,:,:,:,:), intent(in)	a,
		real(sp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 5-d matrix a(:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_5d_int_w()

pure subroutine la_norms::get_norm::norm_5d_int_w	(	complex(qp), dimension(:,:,:,:,:), intent(in)	a,
		real(qp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 5-d matrix a(:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_5d_int_z()

pure subroutine la_norms::get_norm::norm_5d_int_z	(	complex(dp), dimension(:,:,:,:,:), intent(in)	a,
		real(dp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 5-d matrix a(:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_5d_to_4d_char_c()

pure subroutine la_norms::get_norm::norm_5d_to_4d_char_c	(	complex(sp), dimension(:,:,:,:,:), intent(in), target	a,
		real(sp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_5d_to_4d_char_d()

pure subroutine la_norms::get_norm::norm_5d_to_4d_char_d	(	real(dp), dimension(:,:,:,:,:), intent(in), target	a,
		real(dp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_5d_to_4d_char_q()

pure subroutine la_norms::get_norm::norm_5d_to_4d_char_q	(	real(qp), dimension(:,:,:,:,:), intent(in), target	a,
		real(qp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_5d_to_4d_char_s()

pure subroutine la_norms::get_norm::norm_5d_to_4d_char_s	(	real(sp), dimension(:,:,:,:,:), intent(in), target	a,
		real(sp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_5d_to_4d_char_w()

pure subroutine la_norms::get_norm::norm_5d_to_4d_char_w	(	complex(qp), dimension(:,:,:,:,:), intent(in), target	a,
		real(qp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_5d_to_4d_char_z()

pure subroutine la_norms::get_norm::norm_5d_to_4d_char_z	(	complex(dp), dimension(:,:,:,:,:), intent(in), target	a,
		real(dp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_5d_to_4d_int_c()

pure subroutine la_norms::get_norm::norm_5d_to_4d_int_c	(	complex(sp), dimension(:,:,:,:,:), intent(in), target	a,
		real(sp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_5d_to_4d_int_d()

pure subroutine la_norms::get_norm::norm_5d_to_4d_int_d	(	real(dp), dimension(:,:,:,:,:), intent(in), target	a,
		real(dp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_5d_to_4d_int_q()

pure subroutine la_norms::get_norm::norm_5d_to_4d_int_q	(	real(qp), dimension(:,:,:,:,:), intent(in), target	a,
		real(qp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_5d_to_4d_int_s()

pure subroutine la_norms::get_norm::norm_5d_to_4d_int_s	(	real(sp), dimension(:,:,:,:,:), intent(in), target	a,
		real(sp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_5d_to_4d_int_w()

pure subroutine la_norms::get_norm::norm_5d_to_4d_int_w	(	complex(qp), dimension(:,:,:,:,:), intent(in), target	a,
		real(qp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_5d_to_4d_int_z()

pure subroutine la_norms::get_norm::norm_5d_to_4d_int_z	(	complex(dp), dimension(:,:,:,:,:), intent(in), target	a,
		real(dp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_6d_char_c()

pure subroutine la_norms::get_norm::norm_6d_char_c	(	complex(sp), dimension(:,:,:,:,:,:), intent(in)	a,
		real(sp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 6-d matrix a(:,:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_6d_char_d()

pure subroutine la_norms::get_norm::norm_6d_char_d	(	real(dp), dimension(:,:,:,:,:,:), intent(in)	a,
		real(dp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 6-d matrix a(:,:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_6d_char_q()

pure subroutine la_norms::get_norm::norm_6d_char_q	(	real(qp), dimension(:,:,:,:,:,:), intent(in)	a,
		real(qp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 6-d matrix a(:,:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_6d_char_s()

pure subroutine la_norms::get_norm::norm_6d_char_s	(	real(sp), dimension(:,:,:,:,:,:), intent(in)	a,
		real(sp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 6-d matrix a(:,:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_6d_char_w()

pure subroutine la_norms::get_norm::norm_6d_char_w	(	complex(qp), dimension(:,:,:,:,:,:), intent(in)	a,
		real(qp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 6-d matrix a(:,:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_6d_char_z()

pure subroutine la_norms::get_norm::norm_6d_char_z	(	complex(dp), dimension(:,:,:,:,:,:), intent(in)	a,
		real(dp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 6-d matrix a(:,:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_6d_int_c()

pure subroutine la_norms::get_norm::norm_6d_int_c	(	complex(sp), dimension(:,:,:,:,:,:), intent(in)	a,
		real(sp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 6-d matrix a(:,:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_6d_int_d()

pure subroutine la_norms::get_norm::norm_6d_int_d	(	real(dp), dimension(:,:,:,:,:,:), intent(in)	a,
		real(dp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 6-d matrix a(:,:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_6d_int_q()

pure subroutine la_norms::get_norm::norm_6d_int_q	(	real(qp), dimension(:,:,:,:,:,:), intent(in)	a,
		real(qp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 6-d matrix a(:,:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_6d_int_s()

pure subroutine la_norms::get_norm::norm_6d_int_s	(	real(sp), dimension(:,:,:,:,:,:), intent(in)	a,
		real(sp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 6-d matrix a(:,:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_6d_int_w()

pure subroutine la_norms::get_norm::norm_6d_int_w	(	complex(qp), dimension(:,:,:,:,:,:), intent(in)	a,
		real(qp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 6-d matrix a(:,:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_6d_int_z()

pure subroutine la_norms::get_norm::norm_6d_int_z	(	complex(dp), dimension(:,:,:,:,:,:), intent(in)	a,
		real(dp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 6-d matrix a(:,:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_6d_to_5d_char_c()

pure subroutine la_norms::get_norm::norm_6d_to_5d_char_c	(	complex(sp), dimension(:,:,:,:,:,:), intent(in), target	a,
		real(sp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim),merge(size(a,5),size(a,6), mask=5 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_6d_to_5d_char_d()

pure subroutine la_norms::get_norm::norm_6d_to_5d_char_d	(	real(dp), dimension(:,:,:,:,:,:), intent(in), target	a,
		real(dp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim),merge(size(a,5),size(a,6), mask=5 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_6d_to_5d_char_q()

pure subroutine la_norms::get_norm::norm_6d_to_5d_char_q	(	real(qp), dimension(:,:,:,:,:,:), intent(in), target	a,
		real(qp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim),merge(size(a,5),size(a,6), mask=5 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_6d_to_5d_char_s()

pure subroutine la_norms::get_norm::norm_6d_to_5d_char_s	(	real(sp), dimension(:,:,:,:,:,:), intent(in), target	a,
		real(sp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim),merge(size(a,5),size(a,6), mask=5 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_6d_to_5d_char_w()

pure subroutine la_norms::get_norm::norm_6d_to_5d_char_w	(	complex(qp), dimension(:,:,:,:,:,:), intent(in), target	a,
		real(qp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim),merge(size(a,5),size(a,6), mask=5 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_6d_to_5d_char_z()

pure subroutine la_norms::get_norm::norm_6d_to_5d_char_z	(	complex(dp), dimension(:,:,:,:,:,:), intent(in), target	a,
		real(dp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim),merge(size(a,5),size(a,6), mask=5 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_6d_to_5d_int_c()

pure subroutine la_norms::get_norm::norm_6d_to_5d_int_c	(	complex(sp), dimension(:,:,:,:,:,:), intent(in), target	a,
		real(sp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim),merge(size(a,5),size(a,6), mask=5 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_6d_to_5d_int_d()

pure subroutine la_norms::get_norm::norm_6d_to_5d_int_d	(	real(dp), dimension(:,:,:,:,:,:), intent(in), target	a,
		real(dp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim),merge(size(a,5),size(a,6), mask=5 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_6d_to_5d_int_q()

pure subroutine la_norms::get_norm::norm_6d_to_5d_int_q	(	real(qp), dimension(:,:,:,:,:,:), intent(in), target	a,
		real(qp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim),merge(size(a,5),size(a,6), mask=5 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_6d_to_5d_int_s()

pure subroutine la_norms::get_norm::norm_6d_to_5d_int_s	(	real(sp), dimension(:,:,:,:,:,:), intent(in), target	a,
		real(sp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim),merge(size(a,5),size(a,6), mask=5 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_6d_to_5d_int_w()

pure subroutine la_norms::get_norm::norm_6d_to_5d_int_w	(	complex(qp), dimension(:,:,:,:,:,:), intent(in), target	a,
		real(qp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim),merge(size(a,5),size(a,6), mask=5 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_6d_to_5d_int_z()

pure subroutine la_norms::get_norm::norm_6d_to_5d_int_z	(	complex(dp), dimension(:,:,:,:,:,:), intent(in), target	a,
		real(dp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim),merge(size(a,5),size(a,6), mask=5 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_7d_char_c()

pure subroutine la_norms::get_norm::norm_7d_char_c	(	complex(sp), dimension(:,:,:,:,:,:,:), intent(in)	a,
		real(sp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 7-d matrix a(:,:,:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_7d_char_d()

pure subroutine la_norms::get_norm::norm_7d_char_d	(	real(dp), dimension(:,:,:,:,:,:,:), intent(in)	a,
		real(dp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 7-d matrix a(:,:,:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_7d_char_q()

pure subroutine la_norms::get_norm::norm_7d_char_q	(	real(qp), dimension(:,:,:,:,:,:,:), intent(in)	a,
		real(qp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 7-d matrix a(:,:,:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_7d_char_s()

pure subroutine la_norms::get_norm::norm_7d_char_s	(	real(sp), dimension(:,:,:,:,:,:,:), intent(in)	a,
		real(sp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 7-d matrix a(:,:,:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_7d_char_w()

pure subroutine la_norms::get_norm::norm_7d_char_w	(	complex(qp), dimension(:,:,:,:,:,:,:), intent(in)	a,
		real(qp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 7-d matrix a(:,:,:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_7d_char_z()

pure subroutine la_norms::get_norm::norm_7d_char_z	(	complex(dp), dimension(:,:,:,:,:,:,:), intent(in)	a,
		real(dp), intent(out)	nrm,
		character(len=*), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 7-d matrix a(:,:,:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_7d_int_c()

pure subroutine la_norms::get_norm::norm_7d_int_c	(	complex(sp), dimension(:,:,:,:,:,:,:), intent(in)	a,
		real(sp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 7-d matrix a(:,:,:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_7d_int_d()

pure subroutine la_norms::get_norm::norm_7d_int_d	(	real(dp), dimension(:,:,:,:,:,:,:), intent(in)	a,
		real(dp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 7-d matrix a(:,:,:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_7d_int_q()

pure subroutine la_norms::get_norm::norm_7d_int_q	(	real(qp), dimension(:,:,:,:,:,:,:), intent(in)	a,
		real(qp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 7-d matrix a(:,:,:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_7d_int_s()

pure subroutine la_norms::get_norm::norm_7d_int_s	(	real(sp), dimension(:,:,:,:,:,:,:), intent(in)	a,
		real(sp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 7-d matrix a(:,:,:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_7d_int_w()

pure subroutine la_norms::get_norm::norm_7d_int_w	(	complex(qp), dimension(:,:,:,:,:,:,:), intent(in)	a,
		real(qp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 7-d matrix a(:,:,:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_7d_int_z()

pure subroutine la_norms::get_norm::norm_7d_int_z	(	complex(dp), dimension(:,:,:,:,:,:,:), intent(in)	a,
		real(dp), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input 7-d matrix a(:,:,:,:,:,:,:)
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_7d_to_6d_char_c()

pure subroutine la_norms::get_norm::norm_7d_to_6d_char_c	(	complex(sp), dimension(:,:,:,:,:,:,:), intent(in), target	a,
		real(sp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim),merge(size(a,5),size(a,6), mask=5 < dim),merge(size(a,6),size(a,7),mask=6 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_7d_to_6d_char_d()

pure subroutine la_norms::get_norm::norm_7d_to_6d_char_d	(	real(dp), dimension(:,:,:,:,:,:,:), intent(in), target	a,
		real(dp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim),merge(size(a,5),size(a,6), mask=5 < dim),merge(size(a,6),size(a,7),mask=6 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_7d_to_6d_char_q()

pure subroutine la_norms::get_norm::norm_7d_to_6d_char_q	(	real(qp), dimension(:,:,:,:,:,:,:), intent(in), target	a,
		real(qp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim),merge(size(a,5),size(a,6), mask=5 < dim),merge(size(a,6),size(a,7),mask=6 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_7d_to_6d_char_s()

pure subroutine la_norms::get_norm::norm_7d_to_6d_char_s	(	real(sp), dimension(:,:,:,:,:,:,:), intent(in), target	a,
		real(sp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim),merge(size(a,5),size(a,6), mask=5 < dim),merge(size(a,6),size(a,7),mask=6 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_7d_to_6d_char_w()

pure subroutine la_norms::get_norm::norm_7d_to_6d_char_w	(	complex(qp), dimension(:,:,:,:,:,:,:), intent(in), target	a,
		real(qp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim),merge(size(a,5),size(a,6), mask=5 < dim),merge(size(a,6),size(a,7),mask=6 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_7d_to_6d_char_z()

pure subroutine la_norms::get_norm::norm_7d_to_6d_char_z	(	complex(dp), dimension(:,:,:,:,:,:,:), intent(in), target	a,
		real(dp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim),merge(size(a,5),size(a,6), mask=5 < dim),merge(size(a,6),size(a,7),mask=6 < dim)), intent(out)	nrm,
		character(len=*), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_7d_to_6d_int_c()

pure subroutine la_norms::get_norm::norm_7d_to_6d_int_c	(	complex(sp), dimension(:,:,:,:,:,:,:), intent(in), target	a,
		real(sp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim),merge(size(a,5),size(a,6), mask=5 < dim),merge(size(a,6),size(a,7),mask=6 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_7d_to_6d_int_d()

pure subroutine la_norms::get_norm::norm_7d_to_6d_int_d	(	real(dp), dimension(:,:,:,:,:,:,:), intent(in), target	a,
		real(dp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim),merge(size(a,5),size(a,6), mask=5 < dim),merge(size(a,6),size(a,7),mask=6 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_7d_to_6d_int_q()

pure subroutine la_norms::get_norm::norm_7d_to_6d_int_q	(	real(qp), dimension(:,:,:,:,:,:,:), intent(in), target	a,
		real(qp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim),merge(size(a,5),size(a,6), mask=5 < dim),merge(size(a,6),size(a,7),mask=6 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_7d_to_6d_int_s()

pure subroutine la_norms::get_norm::norm_7d_to_6d_int_s	(	real(sp), dimension(:,:,:,:,:,:,:), intent(in), target	a,
		real(sp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim),merge(size(a,5),size(a,6), mask=5 < dim),merge(size(a,6),size(a,7),mask=6 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_7d_to_6d_int_w()

pure subroutine la_norms::get_norm::norm_7d_to_6d_int_w	(	complex(qp), dimension(:,:,:,:,:,:,:), intent(in), target	a,
		real(qp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim),merge(size(a,5),size(a,6), mask=5 < dim),merge(size(a,6),size(a,7),mask=6 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

norm_7d_to_6d_int_z()

pure subroutine la_norms::get_norm::norm_7d_to_6d_int_z	(	complex(dp), dimension(:,:,:,:,:,:,:), intent(in), target	a,
		real(dp), dimension(merge(size(a,1),size(a,2),mask=1 < dim),merge(size(a,2),size(a,3),mask=2 < dim), merge(size(a,3),size(a,4),mask=3 < dim),merge(size(a,4),size(a,5),mask=4 < dim),merge(size(a,5),size(a,6), mask=5 < dim),merge(size(a,6),size(a,7),mask=6 < dim)), intent(out)	nrm,
		integer(ilp), intent(in)	order,
		integer(ilp), intent(in)	dim,
		type(la_state), intent(out), optional	err
	)

Parameters

[in]	a	Input matrix a[..]
[in]	dim	Dimension to collapse by computing the norm w.r.t other dimensions
[out]	nrm	Norm of the matrix.
[in]	order	Order of the matrix norm being computed.
[out]	err	[optional] state return flag. On error if not requested, the code will stop

---

The documentation for this interface was generated from the following file:

• la_norms.f90