Thyra_OperatorVectorTypes.hpp

// @HEADER
// ***********************************************************************
// 
//    Thyra: Interfaces and Support for Abstract Numerical Algorithms
//                 Copyright (2004) Sandia Corporation
// 
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
// 
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//  
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//  
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
// Questions? Contact Michael A. Heroux (maherou@sandia.gov) 
// 
// ***********************************************************************
// @HEADER

#ifndef TSF_CORE_OPERATOR_VECTOR_TYPES_HPP
#define TSF_CORE_OPERATOR_VECTOR_TYPES_HPP

#include "RTOpPack_Types.hpp"
#include "Thyra_Range1D.hpp"
#include "Teuchos_RefCountPtr.hpp"

namespace Thyra {


//
// Basic types
//

typedef RTOp_index_type  Index;

typedef RangePack::Range1D   Range1D;

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: TEST_FOR_EXCEPT(true);
  }
  return "BAD"; // Should never be called!
}

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

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

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

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

inline
ETransp trans_trans( ETransp trans1, ETransp 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
    TEST_FOR_EXCEPT(true);
  return NOTRANS; // Will never be executed!
}

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

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

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


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) {}
//  IncompatibleVectorSpaces(const IncompatibleVectorSpaces& ivs) : std::logic_error(ivs.what()) {}
};

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


} // namespace Exceptions

//
// Thyra
//

// Core abstract interface classes

template<class Scalar>                                        class VectorSpaceFactoryBase;
template<class Scalar>                                        class VectorSpaceBase;
template<class RangeScalar, class DomainScalar = RangeScalar> class LinearOpBase;
template<class Scalar>                                        class MultiVectorBase;
template<class Scalar>                                        class VectorBase;

// Basic node support subclasses and interfaces

template<class Scalar>                                        class ScalarProdBase;
template<class Scalar>                                        class ScalarProdVectorSpaceBase;
template<class RangeScalar, class DomainScalar = RangeScalar> class EuclideanLinearOpBase;
template<class Scalar>                                        class SerialVectorSpaceBase;
template<class Scalar>                                        class SerialVectorBase;

// Basic concrete support subclasses

template<class Scalar> class EuclideanScalarProd;
template<class Scalar> class LinearOpScalarProd;
template<class Scalar> class SerialVectorSpaceFactoryStd;
template<class Scalar> class SerialVectorSpaceStd;
template<class Scalar> class SerialVectorStd;
template<class Scalar> class SerialMultiVectorStd;
template<class Scalar> class MultiVectorCols;
template<class Scalar> class VectorMultiVector;

} // end namespace Thyra

#endif // TSF_CORE_OPERATOR_VECTOR_TYPES_HPP

---