Anasazi_LOCA_MultiVecTraits.H

// $Id: Anasazi_LOCA_MultiVecTraits.H,v 1.6 2007/11/19 23:04:44 cgbaker Exp $ 
// $Source: /space/CVS/Trilinos/packages/nox/src-loca/src/Anasazi_LOCA_MultiVecTraits.H,v $ 

//@HEADER
// ************************************************************************
// 
//            NOX: An Object-Oriented Nonlinear Solver Package
//                 Copyright (2002) Sandia Corporation
// 
//            LOCA: Library of Continuation Algorithms Package
//                 Copyright (2005) 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 Roger Pawlowski (rppawlo@sandia.gov) or 
// Eric Phipps (etphipp@sandia.gov), Sandia National Laboratories.
// ************************************************************************
//  CVS Information
//  $Source: /space/CVS/Trilinos/packages/nox/src-loca/src/Anasazi_LOCA_MultiVecTraits.H,v $
//  $Author: cgbaker $
//  $Date: 2007/11/19 23:04:44 $
//  $Revision: 1.6 $
// ************************************************************************
//@HEADER

#ifndef ANASAZI_LOCA_MULTIVECTRAITS_H
#define ANASAZI_LOCA_MULTIVECTRAITS_H

// Anasazi includes
#include "AnasaziMultiVecTraits.hpp"

// NOX/LOCA includes
#include "NOX_Abstract_MultiVector.H"

namespace Anasazi {
  
  template <>
  class MultiVecTraits<double,NOX::Abstract::MultiVector> {
  public:

    typedef double ScalarType;

    typedef NOX::Abstract::MultiVector MV;


    static Teuchos::RCP<MV> Clone( const MV& mv, const int numvecs ) 
    {
      return mv.clone(numvecs);
    }
      
    static Teuchos::RCP<MV> CloneCopy( const MV& mv ) 
    {
      return mv.clone(NOX::DeepCopy);
    }

    static Teuchos::RCP<MV> CloneCopy( const MV& mv, 
                                               const std::vector<int>& index )
    {
      return mv.subCopy(index);
    }

    static Teuchos::RCP<MV> CloneView( MV& mv, 
                                               const std::vector<int>& index )
    {
      return mv.subView(index);
    }

    static Teuchos::RCP<const MV> CloneView( const MV& mv, 
                                                     const std::vector<int>& index ) 
    {
      return mv.subView(index);
    }



    static int GetVecLength( const MV& mv ) 
    {
      return mv.length();
    }

    static int GetNumberVecs( const MV& mv ) 
    {
      return mv.numVectors();
    }



    static void MvTimesMatAddMv( const ScalarType alpha, const MV& A, 
                                 const Teuchos::SerialDenseMatrix<int,ScalarType>& B, 
                                 const ScalarType beta, MV& mv ) 
    {
      mv.update(Teuchos::NO_TRANS, alpha, A, B, beta);
    }

    static void MvAddMv( const ScalarType alpha, const MV& A, 
                         const ScalarType beta, const MV& B, MV& mv ) 
    {
      mv.update(alpha, A, beta, B);
    }

    static void MvTransMv( const ScalarType alpha, const MV& A, const MV& mv, 
                           Teuchos::SerialDenseMatrix<int,ScalarType>& B) 
    {
      mv.multiply(alpha, A, B);
    }
    
    static void MvDot ( const MV& mv, const MV& A, 
                        std::vector<ScalarType> &b) 
    {
      for (unsigned int i=0; i<b.size(); i++)
        b[i] = A[i].innerProduct(mv[i]);
    }

    static void MvScale ( MV& mv, const ScalarType alpha )
    { 
      mv.scale(alpha); 
    }     
    
    static void MvScale ( MV& mv, const std::vector<ScalarType>& alpha )
    { 
      for (unsigned int i=0; i<alpha.size(); i++)
        mv[i].scale(alpha[i]);
    } 



    static void MvNorm( const MV& mv, 
                        std::vector<double> &normvec ) 
    {
      mv.norm(normvec);
    }



    static void SetBlock( const MV& A, const std::vector<int>& index, MV& mv )
    {
      mv.setBlock(A, index);
    }

    static void MvRandom( MV& mv ) 
    {
      mv.random();
    }

    static void MvInit( MV& mv, 
                        const ScalarType alpha = 0.0 ) 
    {
      mv.init(alpha);
    }



    static void MvPrint( const MV& mv, ostream& os ) 
    {
      mv.print(os);
    }

  }; // class MultiVecTraits
} // namespace Anasazi

#endif 

---