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.
// 
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// 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