- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

# /home/coin/SVN-release/Ipopt-3.2.1/Ipopt/src/LinAlg/IpScaledMatrix.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: IpScaledMatrix.hpp 759 2006-07-07 03:07:08Z andreasw $
    00006 //
    00007 // Authors:  Carl Laird, Andreas Waechter     IBM    2004-08-13
    00008
    00009 #ifndef __IPSCALEDMATRIX_HPP__
    00010 #define __IPSCALEDMATRIX_HPP__
    00011
    00012 #include "IpUtils.hpp"
    00013 #include "IpMatrix.hpp"
    00014
    00015 namespace Ipopt
    00016 {
    00017
    00018   /* forward declarations */
    00019   class ScaledMatrixSpace;
    00020
    00026   class ScaledMatrix : public Matrix
    00027   {
    00028   public:
    00029
    00032
    00035     ScaledMatrix(const ScaledMatrixSpace* owner_space);
    00036
    00038     ~ScaledMatrix();
    00040
    00042     void SetUnscaledMatrix(const SmartPtr<const Matrix> unscaled_matrix);
    00043
    00045     void SetUnscaledMatrixNonConst(const SmartPtr<Matrix>& unscaled_matrix);
    00046
    00048     SmartPtr<const Matrix> GetUnscaledMatrix() const;
    00049
    00051     SmartPtr<Matrix> GetUnscaledMatrixNonConst();
    00052
    00054     SmartPtr<const Vector> RowScaling() const;
    00055
    00057     SmartPtr<const Vector> ColumnScaling() const;
    00058
    00059   protected:
    00062     virtual void MultVectorImpl(Number alpha, const Vector& x,
    00063                                 Number beta, Vector& y) const;
    00064
    00065     virtual void TransMultVectorImpl(Number alpha, const Vector& x,
    00066                                      Number beta, Vector& y) const;
    00067
    00071     virtual bool HasValidNumbersImpl() const;
    00072
    00073     virtual void PrintImpl(const Journalist& jnlst,
    00074                            EJournalLevel level,
    00075                            EJournalCategory category,
    00076                            const std::string& name,
    00077                            Index indent,
    00078                            const std::string& prefix) const;
    00079
    00083     virtual void AddMSinvZImpl(Number alpha, const Vector& S, const Vector& Z,
    00084                                Vector& X) const;
    00085
    00089     virtual void SinvBlrmZMTdBrImpl(Number alpha, const Vector& S,
    00090                                     const Vector& R, const Vector& Z,
    00091                                     const Vector& D, Vector& X) const;
    00093
    00094   private:
    00104     ScaledMatrix();
    00105
    00107     ScaledMatrix(const ScaledMatrix&);
    00108
    00110     void operator=(const ScaledMatrix&);
    00112
    00114     SmartPtr<const Matrix> matrix_;
    00116     SmartPtr<Matrix> nonconst_matrix_;
    00117
    00119     SmartPtr<const ScaledMatrixSpace> owner_space_;
    00120   };
    00121
    00124   class ScaledMatrixSpace : public MatrixSpace
    00125   {
    00126   public:
    00132     ScaledMatrixSpace(const SmartPtr<const Vector>& row_scaling,
    00133                       bool row_scaling_reciprocal,
    00134                       const SmartPtr<const MatrixSpace>& unscaled_matrix_space,
    00135                       const SmartPtr<const Vector>& column_scaling,
    00136                       bool column_scaling_reciprocal);
    00137
    00139     ~ScaledMatrixSpace()
    00140     {}
    00141     ;
    00143
    00145     ScaledMatrix* MakeNewScaledMatrix(bool allocate_unscaled_matrix = false) const
    00146     {
    00147       ScaledMatrix* ret = new ScaledMatrix(this);
    00148       if (allocate_unscaled_matrix) {
    00149         SmartPtr<Matrix> unscaled_matrix = unscaled_matrix_space_->MakeNew();
    00150         ret->SetUnscaledMatrixNonConst(unscaled_matrix);
    00151       }
    00152       return ret;
    00153     }
    00154
    00157     virtual Matrix* MakeNew() const
    00158     {
    00159       return MakeNewScaledMatrix();
    00160     }
    00161
    00163     SmartPtr<const Vector> RowScaling() const
    00164     {
    00165       return ConstPtr(row_scaling_);
    00166     }
    00167
    00169     SmartPtr<const MatrixSpace> UnscaledMatrixSpace() const
    00170     {
    00171       return unscaled_matrix_space_;
    00172     }
    00173
    00175     SmartPtr<const Vector> ColumnScaling() const
    00176     {
    00177       return ConstPtr(column_scaling_);
    00178     }
    00179
    00180   private:
    00190     ScaledMatrixSpace();
    00191
    00193     ScaledMatrixSpace(const ScaledMatrixSpace&);
    00194
    00196     ScaledMatrixSpace& operator=(const ScaledMatrixSpace&);
    00198
    00200     SmartPtr<Vector> row_scaling_;
    00202     SmartPtr<const MatrixSpace> unscaled_matrix_space_;
    00204     SmartPtr<Vector> column_scaling_;
    00205   };
    00206
    00207   inline
    00208   void ScaledMatrix::SetUnscaledMatrix(const SmartPtr<const Matrix> unscaled_matrix)
    00209   {
    00210     matrix_ = unscaled_matrix;
    00211     nonconst_matrix_ = NULL;
    00212     ObjectChanged();
    00213   }
    00214
    00215   inline
    00216   void ScaledMatrix::SetUnscaledMatrixNonConst(const SmartPtr<Matrix>& unscaled_matrix)
    00217   {
    00218     nonconst_matrix_ = unscaled_matrix;
    00219     matrix_ = GetRawPtr(unscaled_matrix);
    00220     ObjectChanged();
    00221   }
    00222
    00223   inline
    00224   SmartPtr<const Matrix> ScaledMatrix::GetUnscaledMatrix() const
    00225   {
    00226     return matrix_;
    00227   }
    00228
    00229   inline
    00230   SmartPtr<Matrix> ScaledMatrix::GetUnscaledMatrixNonConst()
    00231   {
    00232     DBG_ASSERT(IsValid(nonconst_matrix_));
    00233     ObjectChanged();
    00234     return nonconst_matrix_;
    00235   }
    00236
    00237   inline
    00238   SmartPtr<const Vector> ScaledMatrix::RowScaling() const
    00239   {
    00240     return ConstPtr(owner_space_->RowScaling());
    00241   }
    00242
    00243   inline
    00244   SmartPtr<const Vector> ScaledMatrix::ColumnScaling() const
    00245   {
    00246     return ConstPtr(owner_space_->ColumnScaling());
    00247   }
    00248
    00249 } // namespace Ipopt
    00250
    00251 #endif