conjugate.h

Go to the documentation of this file.

// ========================================================================= //
// This file is part of MyraMath, copyright (c) 2014-2019 by Ryan A Chilton  //
// and distributed by MyraCore, LLC. See LICENSE.txt for license terms.      //
// ========================================================================= //

#ifndef MYRAMATH_DENSE_CONJUGATE_H
#define MYRAMATH_DENSE_CONJUGATE_H

#include <myramath/utility/detail/LIBPUBLIC.h>
#include <myramath/utility/Number.h>

namespace myra {

// Containers.
template<class Number> class Matrix;
template<class Number> class Vector;
template<class Number> class LowerMatrix;
template<class Number> class DiagonalMatrix;

// Mutable ranges.
template<class Number> class MatrixRange;
template<class Number> class VectorRange;
template<class Number> class LowerMatrixRange;
template<class Number> class DiagonalMatrixRange;

// Const ranges.
template<class Number> class CMatrixRange;
template<class Number> class CVectorRange;
template<class Number> class CLowerMatrixRange;
template<class Number> class CDiagonalMatrixRange;

LIBPUBLIC Matrix<NumberS> conjugate(const CMatrixRange<NumberS>& A);
LIBPUBLIC Matrix<NumberD> conjugate(const CMatrixRange<NumberD>& A);
LIBPUBLIC Matrix<NumberC> conjugate(const CMatrixRange<NumberC>& A);
LIBPUBLIC Matrix<NumberZ> conjugate(const CMatrixRange<NumberZ>& A);

LIBPUBLIC Vector<NumberS> conjugate(const CVectorRange<NumberS>& x);
LIBPUBLIC Vector<NumberD> conjugate(const CVectorRange<NumberD>& x);
LIBPUBLIC Vector<NumberC> conjugate(const CVectorRange<NumberC>& x);
LIBPUBLIC Vector<NumberZ> conjugate(const CVectorRange<NumberZ>& x);

LIBPUBLIC LowerMatrix<NumberS> conjugate(const CLowerMatrixRange<NumberS>& L);
LIBPUBLIC LowerMatrix<NumberD> conjugate(const CLowerMatrixRange<NumberD>& L);
LIBPUBLIC LowerMatrix<NumberC> conjugate(const CLowerMatrixRange<NumberC>& L);
LIBPUBLIC LowerMatrix<NumberZ> conjugate(const CLowerMatrixRange<NumberZ>& L);

LIBPUBLIC DiagonalMatrix<NumberS> conjugate(const CDiagonalMatrixRange<NumberS>& D);
LIBPUBLIC DiagonalMatrix<NumberD> conjugate(const CDiagonalMatrixRange<NumberD>& D);
LIBPUBLIC DiagonalMatrix<NumberC> conjugate(const CDiagonalMatrixRange<NumberC>& D);
LIBPUBLIC DiagonalMatrix<NumberZ> conjugate(const CDiagonalMatrixRange<NumberZ>& D);

LIBPUBLIC void conjugate_inplace(const MatrixRange<NumberS>& A);
LIBPUBLIC void conjugate_inplace(const MatrixRange<NumberD>& A);
LIBPUBLIC void conjugate_inplace(const MatrixRange<NumberC>& A);
LIBPUBLIC void conjugate_inplace(const MatrixRange<NumberZ>& A);

LIBPUBLIC void conjugate_inplace(const VectorRange<NumberS>& x);
LIBPUBLIC void conjugate_inplace(const VectorRange<NumberD>& x);
LIBPUBLIC void conjugate_inplace(const VectorRange<NumberC>& x);
LIBPUBLIC void conjugate_inplace(const VectorRange<NumberZ>& x);

LIBPUBLIC void conjugate_inplace(const LowerMatrixRange<NumberS>& L);
LIBPUBLIC void conjugate_inplace(const LowerMatrixRange<NumberD>& L);
LIBPUBLIC void conjugate_inplace(const LowerMatrixRange<NumberC>& L);
LIBPUBLIC void conjugate_inplace(const LowerMatrixRange<NumberZ>& L);

LIBPUBLIC void conjugate_inplace(const DiagonalMatrixRange<NumberS>& D);
LIBPUBLIC void conjugate_inplace(const DiagonalMatrixRange<NumberD>& D);
LIBPUBLIC void conjugate_inplace(const DiagonalMatrixRange<NumberC>& D);
LIBPUBLIC void conjugate_inplace(const DiagonalMatrixRange<NumberZ>& D);

// ----------- Conjugating just one triangle.

LIBPUBLIC void conjugate_triangle(const MatrixRange<NumberS>& A, char uplo);
LIBPUBLIC void conjugate_triangle(const MatrixRange<NumberD>& A, char uplo);
LIBPUBLIC void conjugate_triangle(const MatrixRange<NumberC>& A, char uplo);
LIBPUBLIC void conjugate_triangle(const MatrixRange<NumberZ>& A, char uplo);

} // namespace

#endif