utils.hpp File Reference

#include "tlapack/legacy_api/base/legacyArray.hpp"

Include dependency graph for utils.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	tlapack_expr_with_2vectors(x, TX, n, X, incx, y, TY, m, Y, incy, expr)
	Creates two vector objects and executes an expression with them.
#define	tlapack_expr_with_vector(x, TX, n, X, incx, expr)
	Creates a vector object and executes an expression with it.
#define	tlapack_expr_with_vector_positiveInc(x, TX, n, X, incx, expr)
	Creates a vector object and executes an expression with it.

Detailed Description

Author

Weslley S Pereira, University of Colorado Denver, USA

Macro Definition Documentation

tlapack_expr_with_2vectors

#define tlapack_expr_with_2vectors	(		x,
			TX,
			n,
			X,
			incx,
			y,
			TY,
			m,
			Y,
			incy,
			expr
	)

Value:

    do {                                                                       \
        using tlapack::legacy::internal::create_vector;                        \
        using tlapack::legacy::internal::create_backward_vector;               \
        if (incx == 1) {                                                       \
            auto x = create_vector((TX*)X, n);                                 \
            tlapack_expr_with_vector(y, TY, m, Y, incy, expr);                 \
        }                                                                      \
        else if (incx == -1) {                                                 \
            auto x = create_backward_vector((TX*)X, n);                        \
            tlapack_expr_with_vector(y, TY, m, Y, incy, expr);                 \
        }                                                                      \
        else if (incx > 1) {                                                   \
            auto x = create_vector((TX*)X, n, incx);                           \
            tlapack_expr_with_vector(y, TY, m, Y, incy, expr);                 \
        }                                                                      \
        else {                                                                 \
            auto x = create_backward_vector((TX*)X, n, -incx);                 \
            tlapack_expr_with_vector(y, TY, m, Y, incy, expr);                 \
        }                                                                      \
    } while (false)

Creates two vector objects and executes an expression with them.

Parameters

[in]	x	Name of the first vector to be used in the expression.
[in]	TX	Type of the elements of the first vector.
[in]	n	Number of elements in the first vector.
[in]	X	Pointer to the first element of the first vector.
[in]	incx	Stride between elements of the first vector.
[in]	y	Name of the second vector to be used in the expression.
[in]	TY	Type of the elements of the second vector.
[in]	m	Number of elements in the second vector.
[in]	Y	Pointer to the first element of the second vector.
[in]	incy	Stride between elements of the second vector.
[in]	expr	Expression to be executed.

tlapack_expr_with_vector

#define tlapack_expr_with_vector	(		x,
			TX,
			n,
			X,
			incx,
			expr
	)

Value:

    do {                                                         \
        using tlapack::legacy::internal::create_vector;          \
        using tlapack::legacy::internal::create_backward_vector; \
        if (incx == 1) {                                         \
            auto x = create_vector((TX*)X, n);                   \
            expr;                                                \
        }                                                        \
        else if (incx == -1) {                                   \
            auto x = create_backward_vector((TX*)X, n);          \
            expr;                                                \
        }                                                        \
        else if (incx > 1) {                                     \
            auto x = create_vector((TX*)X, n, incx);             \
            expr;                                                \
        }                                                        \
        else {                                                   \
            auto x = create_backward_vector((TX*)X, n, -incx);   \
            expr;                                                \
        }                                                        \
    } while (false)

Creates a vector object and executes an expression with it.

Parameters

[in]	x	Name of the vector to be used in the expression.
[in]	TX	Type of the elements of the vector.
[in]	n	Number of elements in the vector.
[in]	X	Pointer to the first element of the vector.
[in]	incx	Stride between elements of the vector.
[in]	expr	Expression to be executed with the vector.

tlapack_expr_with_vector_positiveInc

#define tlapack_expr_with_vector_positiveInc	(		x,
			TX,
			n,
			X,
			incx,
			expr
	)

Value:

    do {                                                              \
        using tlapack::legacy::internal::create_vector;               \
        if (incx == 1) {                                              \
            auto x = create_vector((TX*)X, n);                        \
            expr;                                                     \
        }                                                             \
        else {                                                        \
            auto x = create_vector((TX*)X, n, incx);                  \
            expr;                                                     \
        }                                                             \
    } while (false)

Creates a vector object and executes an expression with it.

This macro is used when the stride between elements of the vector is non-negative.

Parameters

[in]	x	Name of the vector to be used in the expression.
[in]	TX	Type of the elements of the vector.
[in]	n	Number of elements in the vector.
[in]	X	Pointer to the first element of the vector.
[in]	incx	Stride between elements of the vector.
[in]	expr	Expression to be executed with the vector.