- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

# /home/coin/SVN-release/Ipopt-3.2.1/Ipopt/src/LinAlg/IpSymScaledMatrix.hpp

Go to the documentation of this file.

    00001 // Copyright (C) 2004, 2006 International Business Machines and others.
    00002 // All Rights Reserved.
    00003 // This code is published under the Common Public License.
    00004 //
    00005 // $Id: IpSymScaledMatrix.hpp 759 2006-07-07 03:07:08Z andreasw $
    00006 //
    00007 // Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
    00008
    00009 #ifndef __IPSYMSCALEDMATRIX_HPP__
    00010 #define __IPSYMSCALEDMATRIX_HPP__
    00011
    00012 #include "IpUtils.hpp"
    00013 #include "IpSymMatrix.hpp"
    00014
    00015 namespace Ipopt
    00016 {
    00017
    00018   /* forward declarations */
    00019   class SymScaledMatrixSpace;
    00020
    00026   class SymScaledMatrix : public SymMatrix
    00027   {
    00028   public:
    00029
    00032
    00035     SymScaledMatrix(const SymScaledMatrixSpace* owner_space);
    00036
    00038     ~SymScaledMatrix();
    00040
    00042     void SetUnscaledMatrix(const SmartPtr<const SymMatrix> unscaled_matrix);
    00043
    00045     void SetUnscaledMatrixNonConst(const SmartPtr<SymMatrix>& unscaled_matrix);
    00046
    00048     SmartPtr<const SymMatrix> GetUnscaledMatrix() const;
    00049
    00051     SmartPtr<SymMatrix> GetUnscaledMatrixNonConst();
    00052
    00054     SmartPtr<const Vector> RowColScaling() const;
    00055
    00056   protected:
    00059     virtual void MultVectorImpl(Number alpha, const Vector& x,
    00060                                 Number beta, Vector& y) const;
    00061
    00065     virtual bool HasValidNumbersImpl() const;
    00066
    00067     virtual void PrintImpl(const Journalist& jnlst,
    00068                            EJournalLevel level,
    00069                            EJournalCategory category,
    00070                            const std::string& name,
    00071                            Index indent,
    00072                            const std::string& prefix) const;
    00074
    00075   private:
    00085     SymScaledMatrix();
    00086
    00088     SymScaledMatrix(const SymScaledMatrix&);
    00089
    00091     void operator=(const SymScaledMatrix&);
    00093
    00095     SmartPtr<const SymMatrix> matrix_;
    00097     SmartPtr<SymMatrix> nonconst_matrix_;
    00098
    00100     SmartPtr<const SymScaledMatrixSpace> owner_space_;
    00101   };
    00102
    00105   class SymScaledMatrixSpace : public SymMatrixSpace
    00106   {
    00107   public:
    00113     SymScaledMatrixSpace(const SmartPtr<const Vector>& row_col_scaling,
    00114                          bool row_col_scaling_reciprocal,
    00115                          const SmartPtr<const SymMatrixSpace>& unscaled_matrix_space)
    00116         :
    00117         SymMatrixSpace(unscaled_matrix_space->Dim()),
    00118         unscaled_matrix_space_(unscaled_matrix_space)
    00119     {
    00120       scaling_ = row_col_scaling->MakeNewCopy();
    00121       if (row_col_scaling_reciprocal) {
    00122         scaling_->ElementWiseReciprocal();
    00123       }
    00124     }
    00125
    00127     ~SymScaledMatrixSpace()
    00128     {}
    00129     ;
    00131
    00133     SymScaledMatrix* MakeNewSymScaledMatrix(bool allocate_unscaled_matrix = false) const
    00134     {
    00135       SymScaledMatrix* ret = new SymScaledMatrix(this);
    00136       if (allocate_unscaled_matrix) {
    00137         SmartPtr<SymMatrix> unscaled_matrix = unscaled_matrix_space_->MakeNewSymMatrix();
    00138         ret->SetUnscaledMatrixNonConst(unscaled_matrix);
    00139       }
    00140       return ret;
    00141     }
    00142
    00144     virtual SymMatrix* MakeNewSymMatrix() const
    00145     {
    00146       return MakeNewSymScaledMatrix();
    00147     }
    00150     virtual Matrix* MakeNew() const
    00151     {
    00152       return MakeNewSymScaledMatrix();
    00153     }
    00154
    00156     SmartPtr<const Vector> RowColScaling() const
    00157     {
    00158       return ConstPtr(scaling_);
    00159     }
    00160
    00162     SmartPtr<const SymMatrixSpace> UnscaledMatrixSpace() const
    00163     {
    00164       return unscaled_matrix_space_;
    00165     }
    00166
    00167   private:
    00177     SymScaledMatrixSpace();
    00178
    00180     SymScaledMatrixSpace(const SymScaledMatrixSpace&);
    00181
    00183     SymScaledMatrixSpace& operator=(const SymScaledMatrixSpace&);
    00185
    00187     SmartPtr<Vector> scaling_;
    00189     SmartPtr<const SymMatrixSpace> unscaled_matrix_space_;
    00190   };
    00191
    00192   inline
    00193   void SymScaledMatrix::SetUnscaledMatrix(const SmartPtr<const SymMatrix> unscaled_matrix)
    00194   {
    00195     matrix_ = unscaled_matrix;
    00196     nonconst_matrix_ = NULL;
    00197     ObjectChanged();
    00198   }
    00199
    00200   inline
    00201   void SymScaledMatrix::SetUnscaledMatrixNonConst(const SmartPtr<SymMatrix>& unscaled_matrix)
    00202   {
    00203     nonconst_matrix_ = unscaled_matrix;
    00204     matrix_ = GetRawPtr(unscaled_matrix);
    00205     ObjectChanged();
    00206   }
    00207
    00208   inline
    00209   SmartPtr<const SymMatrix> SymScaledMatrix::GetUnscaledMatrix() const
    00210   {
    00211     return matrix_;
    00212   }
    00213
    00214   inline
    00215   SmartPtr<SymMatrix> SymScaledMatrix::GetUnscaledMatrixNonConst()
    00216   {
    00217     DBG_ASSERT(IsValid(nonconst_matrix_));
    00218     ObjectChanged();
    00219     return nonconst_matrix_;
    00220   }
    00221
    00222   inline SmartPtr<const Vector> SymScaledMatrix::RowColScaling() const
    00223   {
    00224     return ConstPtr(owner_space_->RowColScaling());
    00225   }
    00226
    00227 } // namespace Ipopt
    00228
    00229 #endif