Thyra_OperatorVectorTypes.hpp

// @HEADER
// *****************************************************************************
//    Thyra: Interfaces and Support for Abstract Numerical Algorithms
//
// Copyright 2004 NTESS and the Thyra contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef THYRA_OPERATOR_VECTOR_TYPES_HPP
#define THYRA_OPERATOR_VECTOR_TYPES_HPP
 
#include "Thyra_ConfigDefs.hpp"
#include "RTOpPack_Types.hpp"
#include "Teuchos_Range1D.hpp"
#include "Teuchos_RCP.hpp"
#include "Teuchos_FancyOStream.hpp"
#include "Teuchos_Array.hpp"
#include "Teuchos_ArrayRCP.hpp"
#include "Teuchos_ArrayView.hpp"
#include "Teuchos_Tuple.hpp"
#include "Teuchos_ParameterList.hpp"
#include "Teuchos_ScalarTraits.hpp"
#include "Teuchos_TypeNameTraits.hpp"
 
 
namespace Thyra {
 
// Using declarations from Teuchos

using Teuchos::Ptr;
using Teuchos::RCP;
using Teuchos::Array;
using Teuchos::ArrayView;
using Teuchos::ArrayRCP;
using Teuchos::Tuple;
typedef Teuchos::Range1D Range1D;
using Teuchos::FancyOStream;
using Teuchos::ParameterList;
using Teuchos::ScalarTraits;
using Teuchos::typeName;
using Teuchos::TypeNameTraits;
typedef Teuchos::Ordinal Ordinal;
 

enum EConj {
  NONCONJ_ELE     
  ,CONJ_ELE       
};
 

inline
const char* toString(EConj conj)
{
  switch(conj) {
    case NONCONJ_ELE:    return "NONCONJ_ELE";
    case CONJ_ELE:       return "CONJ_ELE";
    default: TEUCHOS_TEST_FOR_EXCEPT(true);
  }
  // return "BAD"; // Should never be called!
}
 

enum EOpTransp {
  NOTRANS,
  CONJ,
  TRANS,
  CONJTRANS
};
 

inline
const char* toString(EOpTransp transp)
{
  switch(transp) {
    case NOTRANS:    return "NOTRANS";
    case CONJ:       return "CONJ";
    case TRANS:      return "TRANS";
    case CONJTRANS:  return "CONJTRANS";
    default: TEUCHOS_TEST_FOR_EXCEPT(true);
  }
  // return "BAD"; // Should never be called!
}
 

inline
EOpTransp real_trans(EOpTransp transp)
{
  switch(transp) {
    case NOTRANS:    return NOTRANS;
    case CONJ:       return NOTRANS;
    case TRANS:      return TRANS;
    case CONJTRANS:  return TRANS;
    default: TEUCHOS_TEST_FOR_EXCEPT(true);
  }
  // return NOTRANS; // Will never be called!
}
 

inline
EOpTransp not_trans( EOpTransp transp )
{
  switch(transp) {
    case NOTRANS:    return TRANS;
    case CONJ:       return CONJTRANS;
    case TRANS:      return CONJ;
    case CONJTRANS:  return NOTRANS;
    default: TEUCHOS_TEST_FOR_EXCEPT(true);
  }
  // return NOTRANS; // Will never be called!
}
 

inline
EOpTransp trans_trans( EOpTransp trans1, EOpTransp trans2 )
{
  if( trans1 == trans2 )
    return NOTRANS;
  if( trans1 == NOTRANS )
    return trans2;
  if( trans2 == NOTRANS )
    return trans1;
  if( ( trans1 == CONJ && trans2 == TRANS ) || ( trans2 == CONJ && trans1 == TRANS ) )
    return CONJTRANS;
  if( ( trans1 == TRANS && trans2 == CONJTRANS ) || ( trans2 == TRANS && trans1 == CONJTRANS ) )
    return CONJ;
  if( ( trans1 == CONJ && trans2 == CONJTRANS ) || ( trans2 == CONJ && trans1 == CONJTRANS ) )
    return TRANS;
  else
    TEUCHOS_TEST_FOR_EXCEPT(true);
  // return NOTRANS; // Will never be executed!
}
 

inline
EConj transToConj( EOpTransp trans )
{
  switch(trans) {
    case NOTRANS:    return NONCONJ_ELE;
    case CONJ:       return CONJ_ELE;
    case TRANS:      return NONCONJ_ELE;
    case CONJTRANS:  return CONJ_ELE;
    default: TEUCHOS_TEST_FOR_EXCEPT(true);
  }
  // return NONCONJ_ELE; // Will never be called!
}

inline
EOpTransp applyConjToTrans( EConj conj )
{
  switch(conj) {
    case NONCONJ_ELE: return NOTRANS;
    case CONJ_ELE:    return CONJ;
    default: TEUCHOS_TEST_FOR_EXCEPT(true);
  }
  // return NOTRANS; // Will never be called!
}
 

inline
EOpTransp applyTransposeConjToTrans( EConj conj )
{
  switch(conj) {
    case NONCONJ_ELE: return TRANS;
    case CONJ_ELE:    return CONJTRANS;
    default: TEUCHOS_TEST_FOR_EXCEPT(true);
  }
  // return NOTRANS; // Will never be called!
}

enum EViewType {
  VIEW_TYPE_DIRECT   
  ,VIEW_TYPE_DETACHED  
};
 

enum EStrideType {
  STRIDE_TYPE_UNIT,
  STRIDE_TYPE_NONUNIT
};
 
 
namespace Exceptions {
 

class UnInitialized : public std::logic_error
{public: UnInitialized(const std::string& what_arg)
   : std::logic_error(what_arg) {}};
 

class IncompatibleVectorSpaces : public std::logic_error
{public:
  IncompatibleVectorSpaces(const std::string& what_arg)
    : std::logic_error(what_arg) {}
};
 

class OpNotSupported : public std::logic_error
{public: OpNotSupported(const std::string& what_arg)
   : std::logic_error(what_arg) {}};
 
 
} // namespace Exceptions
 
 
// Fundamental ANA operator/vector interface classes
 
 
template<class Scalar> class VectorSpaceFactoryBase;
template<class Scalar> class VectorSpaceBase;
template<class Scalar> class LinearOpBase;
template<class Scalar> class MultiVectorBase;
template<class Scalar> class VectorBase;
 
 
} // end namespace Thyra
 
 
#endif // THYRA_OPERATOR_VECTOR_TYPES_HPP