/home/coin/SVN-release/Ipopt-3.2.4/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

Generated on Thu May 15 22:23:38 2008 by  doxygen 1.4.7