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
|
// ************************************************************************************************
//
// BornAgain: simulate and fit reflection and scattering
//
//! @file Fit/Param/AttLimits.cpp
//! @brief Implements and implements class AttLimits.
//!
//! @homepage http://www.bornagainproject.org
//! @license GNU General Public License v3 or higher (see COPYING)
//! @copyright Forschungszentrum Jülich GmbH 2018
//! @authors Scientific Computing Group at MLZ (see CITATION, AUTHORS)
//
// ************************************************************************************************
#include "Fit/Param/AttLimits.h"
#include <iomanip>
#include <sstream>
AttLimits::AttLimits()
: m_limits(RealLimits::limitless())
, m_fixed(false)
{
}
AttLimits::AttLimits(const RealLimits& limits, bool fixed)
: m_limits(limits)
, m_fixed(fixed)
{
}
AttLimits AttLimits::limitless()
{
return AttLimits();
}
AttLimits AttLimits::lowerLimited(double bound_value)
{
return AttLimits(RealLimits::lowerLimited(bound_value), false);
}
AttLimits AttLimits::positive()
{
return AttLimits(RealLimits::positive(), false);
}
AttLimits AttLimits::nonnegative()
{
return AttLimits(RealLimits::nonnegative(), false);
}
AttLimits AttLimits::upperLimited(double bound_value)
{
return AttLimits(RealLimits::upperLimited(bound_value), false);
}
AttLimits AttLimits::limited(double left_bound_value, double right_bound_value)
{
return AttLimits(RealLimits::limited(left_bound_value, right_bound_value), false);
}
AttLimits AttLimits::fixed()
{
return AttLimits(RealLimits::limitless(), true);
}
bool AttLimits::isFixed() const
{
return m_fixed;
}
bool AttLimits::isLimited() const
{
return !m_fixed && m_limits.isLimited();
}
bool AttLimits::isUpperLimited() const
{
return !m_fixed && !m_limits.hasLowerLimit() && m_limits.hasUpperLimit();
}
bool AttLimits::isLowerLimited() const
{
return !m_fixed && m_limits.hasLowerLimit() && !m_limits.hasUpperLimit();
}
bool AttLimits::isLimitless() const
{
return !m_fixed && !m_limits.hasLowerLimit() && !m_limits.hasUpperLimit();
}
double AttLimits::min() const
{
return m_limits.min();
}
double AttLimits::max() const
{
return m_limits.max();
}
bool AttLimits::operator==(const AttLimits& other) const
{
return m_limits == other.m_limits && m_fixed == other.m_fixed;
}
bool AttLimits::operator!=(const AttLimits& other) const
{
return !(*this == other);
}
std::string AttLimits::toString() const
{
std::ostringstream result;
if (isFixed())
result << "fixed";
else if (isLimitless())
result << "free";
else if (isLowerLimited())
result << "lowerLimited(" << std::scientific << std::setprecision(2) << min() << ")";
else if (isUpperLimited())
result << "upperLimited(" << std::scientific << std::setprecision(2) << max() << ")";
else if (isLimited())
result << "limited(" << std::scientific << std::setprecision(2) << min() << ","
<< std::scientific << std::setprecision(2) << max() << ")";
return result.str();
}
|
