AbstractLinAlgPack_MatrixSymAddDelUpdateable.hpp

// @HEADER
// ***********************************************************************
// 
// Moocho: Multi-functional Object-Oriented arCHitecture for Optimization
//                  Copyright (2003) 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 Roscoe A. Bartlett (rabartl@sandia.gov) 
// 
// ***********************************************************************
// @HEADER

#ifndef MATRIX_SYM_ADD_DEL_UPDATEABLE_H
#define MATRIX_SYM_ADD_DEL_UPDATEABLE_H

#include "AbstractLinAlgPack_Types.hpp"
#include "AbstractLinAlgPack_MatrixBase.hpp"

namespace AbstractLinAlgPack {

class MatrixSymAddDelUpdateable
  : public virtual AbstractLinAlgPack::MatrixBase // doxygen needs full name
{
public:


  enum EEigenValType { EIGEN_VAL_POS, EIGEN_VAL_NEG, EIGEN_VAL_ZERO, EIGEN_VAL_UNKNOWN };
  struct Inertia {
        enum { UNKNOWN = -1 };
    Inertia(
      int neg_eigen_vals    = UNKNOWN
      ,int zero_eigen_vals  = UNKNOWN
      ,int pos_eigen_vals  = UNKNOWN
      )
      : neg_eigens(neg_eigen_vals)
      ,zero_eigens(zero_eigen_vals)
      ,pos_eigens(pos_eigen_vals)
      {}
    int  neg_eigens;
    int  zero_eigens;
    int  pos_eigens;
  }; 
  struct PivotTolerances {
    enum { UNKNOWN = -1 };
    PivotTolerances()              // 2001/03/08: g++ 2.95.2 requries separate
      :warning_tol(UNKNOWN)      // constructor for use in default argument
      ,singular_tol(UNKNOWN)     // or you get internalcomplier error later?
      ,wrong_inertia_tol(UNKNOWN)
      {}
    PivotTolerances(
      value_type  _warning_tol
      ,value_type _singular_tol
      ,value_type _wrong_inertia_tol
      )
      :warning_tol(_warning_tol)
      ,singular_tol(_singular_tol)
      ,wrong_inertia_tol(_wrong_inertia_tol)
      {}
    value_type warning_tol;
    value_type singular_tol;
    value_type wrong_inertia_tol;
  };
  class WarnNearSingularUpdateException : public std::logic_error {
  public:
    WarnNearSingularUpdateException(const std::string& what_arg,value_type _gamma)
      : std::logic_error(what_arg), gamma(_gamma) {}
    value_type gamma;
  };
  class SingularUpdateException : public std::logic_error {
  public:
    SingularUpdateException(const std::string& what_arg,value_type _gamma)
      : std::logic_error(what_arg), gamma(_gamma) {}
    value_type gamma;
  };
  class WrongInertiaUpdateException : public std::logic_error {
  public:
    WrongInertiaUpdateException(const std::string& what_arg,value_type _gamma)
      : std::logic_error(what_arg), gamma(_gamma) {}
    value_type gamma;
  };
  class MaxSizeExceededException : public std::logic_error
  {public: MaxSizeExceededException(const std::string& what_arg) : std::logic_error(what_arg) {}};



  virtual ~MatrixSymAddDelUpdateable()
  {}

  virtual void initialize(
    value_type    alpha
    , size_type   max_size
    ) = 0;

  virtual void initialize(
    const DMatrixSliceSym      &A
    ,size_type         max_size
    ,bool              force_factorization
    ,Inertia           inertia
    ,PivotTolerances   pivot_tols            = PivotTolerances()
    ) = 0;

  virtual size_type max_size() const = 0;

  virtual Inertia inertia() const = 0;

  virtual void set_uninitialized() = 0;

  virtual void augment_update(
    const DVectorSlice  *t
    ,value_type        alpha
    ,bool              force_refactorization = true
    ,EEigenValType     add_eigen_val         = EIGEN_VAL_UNKNOWN
    ,PivotTolerances   pivot_tols            = PivotTolerances()
    ) = 0;

  virtual void delete_update(
    size_type          jd
    ,bool              force_refactorization = true
    ,EEigenValType     drop_eigen_val        = EIGEN_VAL_UNKNOWN
    ,PivotTolerances   pivot_tols            = PivotTolerances()
    ) = 0;


}; // end class MatrixSymAddDelUpdateable

}  // namespace AbstractLinAlgPack 

#endif // MATRIX_SYM_ADD_DEL_UPDATEABLE_H