Debian Codegraph @

Source/Reasoner/Ontology/CDataLiteralFloatValue.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 "CDataLiteralFloatValue.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Ontology {
29
30
31 CDataLiteralFloatValue::CDataLiteralFloatValue() {
32 clearValue();
33 }
34
35
36 CDataLiteralValue::DATA_LITERAL_VALUE_TYPE CDataLiteralFloatValue::getDataValueType() {
37 return CDataLiteralValue::DLVT_FLOAT;
38 }
39
40
41
42 QString CDataLiteralFloatValue::getValueString() {
43 return QString::number(mFloat);
44 }
45
46
47 CDataLiteralCompareValue* CDataLiteralFloatValue::initValue(CDataLiteralCompareValue* value) {
48 clearValue();
49 CDataLiteralFloatValue* floatValue = dynamic_cast<CDataLiteralFloatValue*>(value);
50 if (floatValue) {
51 mFloat = floatValue->mFloat;
52 }
53 return this;
54 }
55
56
57 CDataLiteralFloatValue* CDataLiteralFloatValue::initValueFromFloat(float floatValue) {
58 clearValue();
59 mFloat = floatValue;
60 return this;
61 }
62
63 CDataLiteralFloatValue* CDataLiteralFloatValue::initValueFromInfinite(bool negative) {
64 clearValue();
65 if (negative) {
66 mFloat = -std::numeric_limits<float>::infinity();
67 } else {
68 mFloat = std::numeric_limits<float>::infinity();
69 }
70 return this;
71 }
72
73
74 CDataLiteralFloatValue* CDataLiteralFloatValue::initValue(CDataLiteralFloatValue* value) {
75 if (value) {
76 mFloat = value->mFloat;
77 }
78 return this;
79 }
80
81
82 CDataLiteralFloatValue* CDataLiteralFloatValue::clearValue() {
83 mFloat = 0.;
84 return this;
85 }
86
87
88 float CDataLiteralFloatValue::getFloat() {
89 return mFloat;
90 }
91
92
93
94 bool CDataLiteralFloatValue::isInfinite() {
95 if (mFloat >= std::numeric_limits<float>::infinity()) {
96 return true;
97 }
98 if (mFloat <= -std::numeric_limits<float>::infinity()) {
99 return true;
100 }
101 return false;
102 }
103
104 bool CDataLiteralFloatValue::isNegative() {
105 return mFloat < 0;
106 }
107
108
109 bool CDataLiteralFloatValue::isEqualTo(CDataLiteralValue* value) {
110 CDataLiteralFloatValue* floatValue = dynamic_cast<CDataLiteralFloatValue*>(value);
111 if (floatValue) {
112 return isEqualTo(floatValue);
113 }
114 return false;
115 }
116
117
118
119 bool CDataLiteralFloatValue::isLessEqualThan(CDataLiteralCompareValue* value) {
120 CDataLiteralFloatValue* floatValue = dynamic_cast<CDataLiteralFloatValue*>(value);
121 if (floatValue) {
122 return isEqualTo(floatValue) || isLessThan(floatValue);
123 }
124 return false;
125 }
126
127 bool CDataLiteralFloatValue::isLessEqualThan(CDataLiteralFloatValue* floatValue) {
128 return isEqualTo(floatValue) || isLessThan(floatValue);
129 }
130
131
132 bool CDataLiteralFloatValue::isEqualTo(CDataLiteralCompareValue* value) {
133 CDataLiteralFloatValue* floatValue = dynamic_cast<CDataLiteralFloatValue*>(value);
134 if (floatValue) {
135 return isEqualTo(floatValue);
136 }
137 return false;
138 }
139
140 bool CDataLiteralFloatValue::isEqualTo(CDataLiteralFloatValue* floatValue) {
141 return mFloat == floatValue->mFloat;
142 }
143
144 bool CDataLiteralFloatValue::isGreaterEqualThan(CDataLiteralFloatValue* floatValue) {
145 return isEqualTo(floatValue) || isGreaterThan(floatValue);
146 }
147
148 bool CDataLiteralFloatValue::isGreaterEqualThan(CDataLiteralCompareValue* value) {
149 CDataLiteralFloatValue* floatValue = dynamic_cast<CDataLiteralFloatValue*>(value);
150 if (floatValue) {
151 return isEqualTo(floatValue) || isGreaterThan(floatValue);
152 }
153 return false;
154 }
155
156 bool CDataLiteralFloatValue::isGreaterThan(CDataLiteralCompareValue* value) {
157 return value->isLessThan(this);
158 }
159
160 bool CDataLiteralFloatValue::isGreaterThan(CDataLiteralFloatValue* floatValue) {
161 return floatValue->isLessThan(this);
162 }
163
164
165 bool CDataLiteralFloatValue::isLessThan(CDataLiteralCompareValue* value) {
166 CDataLiteralFloatValue* floatValue = dynamic_cast<CDataLiteralFloatValue*>(value);
167 if (floatValue) {
168 return isLessThan(floatValue);
169 }
170 return false;
171 }
172
173
174 bool CDataLiteralFloatValue::isLessThan(CDataLiteralFloatValue* floatValue) {
175 if (mFloat < floatValue->mFloat) {
176 return true;
177 } else {
178 return false;
179 }
180 }
181
182
183 }; // end namespace Ontology
184
185 }; // end namespace Reasoner
186
187 }; // end namespace Konclude