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 2269 2013-05-05 11:32:40Z 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
|
