Debian Codegraph @

Source/Reasoner/Ontology/CDataLiteralDoubleValue.cpp

raw
1 /*
2 * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team.
3 *
4 * This file is part of the reasoning system Konclude.
5 * For details and support, see <http://konclude.com/>.
6 *
7 * Konclude is free software: you can redistribute it and/or modify
8 * it under the terms of version 3 of the GNU Lesser General Public
9 * License (LGPLv3) as published by the Free Software Foundation.
10 *
11 * Konclude is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU (Lesser) General Public License for more details.
15 *
16 * You should have received a copy of the GNU (Lesser) General Public
17 * License along with Konclude. If not, see <http://www.gnu.org/licenses/>.
18 *
19 */
20
21 #include "CDataLiteralDoubleValue.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Ontology {
29
30
31 CDataLiteralDoubleValue::CDataLiteralDoubleValue() {
32 clearValue();
33 }
34
35
36 CDataLiteralValue::DATA_LITERAL_VALUE_TYPE CDataLiteralDoubleValue::getDataValueType() {
37 return CDataLiteralValue::DLVT_DOUBLE;
38 }
39
40
41
42 CDataLiteralCompareValue* CDataLiteralDoubleValue::initValue(CDataLiteralCompareValue* value) {
43 clearValue();
44 CDataLiteralDoubleValue* doubleValue = dynamic_cast<CDataLiteralDoubleValue*>(value);
45 if (doubleValue) {
46 mDouble = doubleValue->mDouble;
47 }
48 return this;
49 }
50
51 QString CDataLiteralDoubleValue::getValueString() {
52 return QString::number(mDouble);
53 }
54
55
56
57 CDataLiteralDoubleValue* CDataLiteralDoubleValue::initValueFromDouble(double doubleValue) {
58 clearValue();
59 mDouble = doubleValue;
60 return this;
61 }
62
63
64 CDataLiteralDoubleValue* CDataLiteralDoubleValue::initValueFromInfinite(bool negative) {
65 clearValue();
66 if (negative) {
67 mDouble = -std::numeric_limits<double>::infinity();
68 } else {
69 mDouble = std::numeric_limits<double>::infinity();
70 }
71 return this;
72 }
73
74 CDataLiteralDoubleValue* CDataLiteralDoubleValue::initValue(CDataLiteralDoubleValue* value) {
75 if (value) {
76 mDouble = value->mDouble;
77 }
78 return this;
79 }
80
81
82 CDataLiteralDoubleValue* CDataLiteralDoubleValue::clearValue() {
83 mDouble = 0.;
84 return this;
85 }
86
87
88 double CDataLiteralDoubleValue::getDouble() {
89 return mDouble;
90 }
91
92
93 bool CDataLiteralDoubleValue::isInfinite() {
94 if (mDouble >= std::numeric_limits<double>::infinity()) {
95 return true;
96 }
97 if (mDouble <= -std::numeric_limits<double>::infinity()) {
98 return true;
99 }
100 return false;
101 }
102
103 bool CDataLiteralDoubleValue::isNegative() {
104 return mDouble < 0;
105 }
106
107 bool CDataLiteralDoubleValue::isEqualTo(CDataLiteralValue* value) {
108 CDataLiteralDoubleValue* doubleValue = dynamic_cast<CDataLiteralDoubleValue*>(value);
109 if (doubleValue) {
110 return isEqualTo(doubleValue);
111 }
112 return false;
113 }
114
115
116
117 bool CDataLiteralDoubleValue::isLessEqualThan(CDataLiteralCompareValue* value) {
118 CDataLiteralDoubleValue* doubleValue = dynamic_cast<CDataLiteralDoubleValue*>(value);
119 if (doubleValue) {
120 return isEqualTo(doubleValue) || isLessThan(doubleValue);
121 }
122 return false;
123 }
124
125 bool CDataLiteralDoubleValue::isLessEqualThan(CDataLiteralDoubleValue* doubleValue) {
126 return isEqualTo(doubleValue) || isLessThan(doubleValue);
127 }
128
129
130 bool CDataLiteralDoubleValue::isEqualTo(CDataLiteralCompareValue* value) {
131 CDataLiteralDoubleValue* doubleValue = dynamic_cast<CDataLiteralDoubleValue*>(value);
132 if (doubleValue) {
133 return isEqualTo(doubleValue);
134 }
135 return false;
136 }
137
138 bool CDataLiteralDoubleValue::isEqualTo(CDataLiteralDoubleValue* doubleValue) {
139 return mDouble == doubleValue->mDouble;
140 }
141
142 bool CDataLiteralDoubleValue::isGreaterEqualThan(CDataLiteralDoubleValue* doubleValue) {
143 return isEqualTo(doubleValue) || isGreaterThan(doubleValue);
144 }
145
146 bool CDataLiteralDoubleValue::isGreaterEqualThan(CDataLiteralCompareValue* value) {
147 CDataLiteralDoubleValue* doubleValue = dynamic_cast<CDataLiteralDoubleValue*>(value);
148 if (doubleValue) {
149 return isEqualTo(doubleValue) || isGreaterThan(doubleValue);
150 }
151 return false;
152 }
153
154 bool CDataLiteralDoubleValue::isGreaterThan(CDataLiteralCompareValue* value) {
155 return value->isLessThan(this);
156 }
157
158 bool CDataLiteralDoubleValue::isGreaterThan(CDataLiteralDoubleValue* doubleValue) {
159 return doubleValue->isLessThan(this);
160 }
161
162
163 bool CDataLiteralDoubleValue::isLessThan(CDataLiteralCompareValue* value) {
164 CDataLiteralDoubleValue* doubleValue = dynamic_cast<CDataLiteralDoubleValue*>(value);
165 if (doubleValue) {
166 return isLessThan(doubleValue);
167 }
168 return false;
169 }
170
171
172 bool CDataLiteralDoubleValue::isLessThan(CDataLiteralDoubleValue* doubleValue) {
173 if (mDouble < doubleValue->mDouble) {
174 return true;
175 } else {
176 return false;
177 }
178 }
179
180
181 }; // end namespace Ontology
182
183 }; // end namespace Reasoner
184
185 }; // end namespace Konclude