FilesExpand file tree

 master

/

MatrixBaseAddons.h

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

141 lines (127 loc) · 3.69 KB

 master

/

MatrixBaseAddons.h

Copy path

Top

File metadata and controls

• Code
• Blame

141 lines (127 loc) · 3.69 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

/**

* @file MatrixBaseAddons.h

* Extends eigen3 base class to include supporting functionality for the

* max-sum library. The methods defined here will be available in all eigen

* types, including the maxsum::DiscreteFunction, which is derived from

* these base types.

*/

/**

* Adds a list of Functions to this one, expanding the domain if

* necessary.

* The result is \f$this + \sum_k funcs[k]\f$

* @todo Make this more efficient by expanding domain in advance.

* @returns reference to this function.

*/

template<class VecIt> Derived& add(VecIt begin, VecIt end)

{

for(VecIt it=begin; it!=end; ++it)

{

(*this) += *it;

}

return *this;

}

/**

* Access coefficient using scalar index.

* This is equivalent to DiscreteFunction::operator()(maxsum::ValIndex ind)

* but is more convenient when for use with pointers e.g.

* <pre>

* x->(k); // illegal

* x->at(k); // ok

* </pre>

* @see DiscreteFunction::operator()(maxsum::ValIndex ind)

*/

Scalar& at(Index ind)

{

return (*this)(ind);

}

/**

* Access coefficient using scalar index.

* This is equivalent to DiscreteFunction::operator()(maxsum::ValIndex ind) const

* but is more convenient when for use with pointers e.g.

* <pre>

* x->(k); // illegal

* x->at(k); // ok

* </pre>

* @see DiscreteFunction::operator()(maxsum::ValIndex ind) const

*/

Scalar at(Index ind) const

{

return (*this)(ind);

}

/**

* Returns the minimum scalar value of the function across entire domain.

*/

Scalar min() const { return array().minCoeff(); }

/**

* Returns the maximum scalar value for function across entire domain.

*/

Scalar max() const { return array().maxCoeff(); }

/**

* Returns the linear index of the maximum value across entire domain.

*/

Index argmax() const

{

Index result;

array().maxCoeff(&result);

return result;

}

/**

* Returns the linear index of the 2nd largest value.

* Example usage:

* <p>

* <code>

* ValIndex mx1 = fun.argmax();

* ValIndex mx2 = fun.argmax2(mx1);

* </code>

* </p>

* @param mxInd the value returned by DiscreteFunction::argmax()

* This is the maximum of the set of values, excluding the largest one,

* returned by DiscreteFunction::argmax

*/

Index argmax2(Index mxInd) const

{

//**************************************************************************

// Setup arrays to store the max and argmax for the head and tail of this

// array (excluding the maximum at mxInd).

//**************************************************************************

Array<Scalar,2,1> maxVals;

maxVals << at(0), at(0);

Array<Index,2,1> maxInds;

maxInds << 0, 0;

//**************************************************************************

// Find the argmax for head

//**************************************************************************

if(0<mxInd)

{

maxVals(0) = head(mxInd).array().maxCoeff(&maxInds(0));

}

//**************************************************************************

// Find the argmax for the tail

//**************************************************************************

if( (mxInd+1) < size() )

{

maxVals(1) = tail(size()-mxInd).array().maxCoeff(&maxInds(1));

}

//**************************************************************************

// Return which ever is the maximum

//**************************************************************************

if(maxVals(0)>maxVals(1))

{

return maxInds(0);

}

else

{

return mxInd+1+maxInds(1);

}

} // argmx2

/**

* Returns the maxnorm for this function.

* The maxnorm is defined as the maximum absolute value of the function:

* \f[

* \|f(k)\|_{\infty} = \max_k |f(k)|

* \f]

*/

Scalar maxnorm() const

{

return array().abs().maxCoeff();

}