/usr/include/coin/IpSymMatrix.hpp is in coinor-libipopt-dev 3.11.9-2.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 | // Copyright (C) 2004, 2008 International Business Machines and others.
// All Rights Reserved.
// This code is published under the Eclipse Public License.
//
// $Id: IpSymMatrix.hpp 2161 2013-01-01 20:39:05Z stefan $
//
// Authors: Carl Laird, Andreas Waechter IBM 2004-08-13
#ifndef __IPSYMMATRIX_HPP__
#define __IPSYMMATRIX_HPP__
#include "IpUtils.hpp"
#include "IpMatrix.hpp"
namespace Ipopt
{
/* forward declarations */
class SymMatrixSpace;
/** This is the base class for all derived symmetric matrix types.
*/
class SymMatrix : public Matrix
{
public:
/** @name Constructor/Destructor */
//@{
/** Constructor, taking the owner_space.
*/
inline
SymMatrix(const SymMatrixSpace* owner_space);
/** Destructor */
virtual ~SymMatrix()
{}
//@}
/** @name Information about the size of the matrix */
//@{
/** Dimension of the matrix (number of rows and columns) */
inline
Index Dim() const;
//@}
inline
SmartPtr<const SymMatrixSpace> OwnerSymMatrixSpace() const;
protected:
/** @name Overloaded methods from Matrix. */
//@{
/** Since the matrix is
* symmetric, it is only necessary to implement the
* MultVectorImpl method in a class that inherits from this base
* class. If the TransMultVectorImpl is called, this base class
* automatically calls MultVectorImpl instead. */
virtual void TransMultVectorImpl(Number alpha, const Vector& x, Number beta,
Vector& y) const
{
// Since this matrix is symetric, this is the same operation as
// MultVector
MultVector(alpha, x, beta, y);
}
/** Since the matrix is symmetric, the row and column max norms
* are identical */
virtual void ComputeColAMaxImpl(Vector& cols_norms, bool init) const
{
ComputeRowAMaxImpl(cols_norms, init);
}
//@}
private:
/** Copy of the owner space ptr as a SymMatrixSpace instead
* of a MatrixSpace
*/
const SymMatrixSpace* owner_space_;
};
/** SymMatrixSpace base class, corresponding to the SymMatrix base
* class. */
class SymMatrixSpace : public MatrixSpace
{
public:
/** @name Constructors/Destructors */
//@{
/** Constructor, given the dimension (identical to the number of
* rows and columns).
*/
SymMatrixSpace(Index dim)
:
MatrixSpace(dim,dim)
{}
/** Destructor */
virtual ~SymMatrixSpace()
{}
//@}
/** Pure virtual method for creating a new matrix of this specific
* type. */
virtual SymMatrix* MakeNewSymMatrix() const=0;
/** Overloaded MakeNew method for the MatrixSpace base class.
*/
virtual Matrix* MakeNew() const
{
return MakeNewSymMatrix();
}
/** Accessor method for the dimension of the matrices in this
* matrix space.
*/
Index Dim() const
{
DBG_ASSERT(NRows() == NCols());
return NRows();
}
private:
/**@name Default Compiler Generated Methods
* (Hidden to avoid implicit creation/calling).
* These methods are not implemented and
* we do not want the compiler to implement
* them for us, so we declare them private
* and do not define them. This ensures that
* they will not be implicitly created/called. */
//@{
/** default constructor */
SymMatrixSpace();
/* Copy constructor */
SymMatrixSpace(const SymMatrixSpace&);
/** Overloaded Equals Operator */
SymMatrixSpace& operator=(const SymMatrixSpace&);
//@}
};
/* inline methods */
inline
SymMatrix::SymMatrix(const SymMatrixSpace* owner_space)
:
Matrix(owner_space),
owner_space_(owner_space)
{}
inline
Index SymMatrix::Dim() const
{
return owner_space_->Dim();
}
inline
SmartPtr<const SymMatrixSpace> SymMatrix::OwnerSymMatrixSpace() const
{
return owner_space_;
}
} // namespace Ipopt
#endif
|