Debian Codegraph @

Source/Reasoner/Ontology/CDataLiteralRealValue.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 "CDataLiteralRealValue.h"
22
23
24 namespace Konclude {
25
26 namespace Reasoner {
27
28 namespace Ontology {
29
30
31 CDataLiteralRealValue::CDataLiteralRealValue() {
32 clearValue();
33 }
34
35
36 CDataLiteralValue::DATA_LITERAL_VALUE_TYPE CDataLiteralRealValue::getDataValueType() {
37 return CDataLiteralValue::DLVT_REAL;
38 }
39
40
41
42 QString CDataLiteralRealValue::getValueString() {
43 QString valueString;
44 if (mNegative) {
45 valueString += "-";
46 }
47 valueString += QString::number(mInteger);
48 if (mNumerator != 0) {
49 valueString += " ";
50 valueString += QString::number(mNumerator);
51 valueString += "/";
52 valueString += QString::number(mDenominator);
53 }
54 return valueString;
55 }
56
57
58 CDataLiteralCompareValue* CDataLiteralRealValue::initValue(CDataLiteralCompareValue* value) {
59 clearValue();
60 CDataLiteralRealValue* realValue = dynamic_cast<CDataLiteralRealValue*>(value);
61 if (realValue) {
62 mInfinite = realValue->mInfinite;
63 mNegative = realValue->mNegative;
64 mInteger = realValue->mInteger;
65 mNumerator = realValue->mNumerator;
66 mDenominator = realValue->mDenominator;
67 mFlags = realValue->mFlags;
68 }
69 return this;
70 }
71
72
73 CDataLiteralRealValue* CDataLiteralRealValue::initRationalValueFromInfinite(bool negative) {
74 clearValue();
75 mNegative = negative;
76 mInfinite = true;
77 normalize();
78 mFlags |= DLRV_RATIONAL_FLAG;
79 identifyFlags();
80 return this;
81 }
82
83 CDataLiteralRealValue* CDataLiteralRealValue::initRationalValueFromDecimal(cint64 integerValue, cint64 decimalValue, cint64 precedingZerors) {
84 initRationalValueFromInteger(integerValue);
85 clearFlags();
86 if (decimalValue < 0) {
87 mNegative = !mNegative;
88 decimalValue = -decimalValue;
89 }
90 mNumerator = decimalValue;
91 mDenominator = 1;
92 while (mDenominator < decimalValue) {
93 mDenominator *= 10;
94 }
95 while (precedingZerors > 0) {
96 --precedingZerors;
97 mDenominator *= 10;
98 }
99 normalize();
100 mFlags |= DLRV_DECIMAL_FLAG | DLRV_RATIONAL_FLAG;
101 identifyFlags();
102 return this;
103 }
104
105 CDataLiteralRealValue* CDataLiteralRealValue::initRationalValueFromDecimal(cuint64 integerValue, cuint64 decimalValue, bool negative, cint64 precedingZerors) {
106 initRationalValueFromInteger(integerValue,negative);
107 clearFlags();
108 mNumerator = decimalValue;
109 mDenominator = 1;
110 while (mDenominator <= decimalValue) {
111 mDenominator *= 10;
112 }
113 while (precedingZerors > 0) {
114 --precedingZerors;
115 mDenominator *= 10;
116 }
117 normalize();
118 mFlags |= DLRV_DECIMAL_FLAG | DLRV_RATIONAL_FLAG;
119 identifyFlags();
120 return this;
121 }
122
123
124 CDataLiteralRealValue* CDataLiteralRealValue::initRationalValueFromFraction(cint64 numeratorValue, cint64 denominatorValue) {
125 clearValue();
126 if (numeratorValue < 0 && denominatorValue < 0) {
127 numeratorValue = -numeratorValue;
128 denominatorValue = -denominatorValue;
129 } else if (numeratorValue < 0) {
130 numeratorValue = -numeratorValue;
131 mNegative = true;
132 } else if (denominatorValue < 0) {
133 denominatorValue = -denominatorValue;
134 mNegative = true;
135 }
136 mNumerator = numeratorValue;
137 mDenominator = denominatorValue;
138 normalize();
139 mFlags |= DLRV_RATIONAL_FLAG;
140 identifyFlags();
141 return this;
142 }
143
144
145 CDataLiteralRealValue* CDataLiteralRealValue::initRationalValueFromFraction(cuint64 numeratorValue, cuint64 denominatorValue, bool negative) {
146 clearValue();
147 mNumerator = numeratorValue;
148 mDenominator = denominatorValue;
149 mNegative = negative;
150 normalize();
151 mFlags |= DLRV_RATIONAL_FLAG;
152 identifyFlags();
153 return this;
154 }
155
156
157 CDataLiteralRealValue* CDataLiteralRealValue::initRationalValueFromNextIntegerValue(CDataLiteralRealValue* value) {
158 clearValue();
159 mNegative = value->mNegative;
160 mInteger = value->mInteger;
161 if (mNegative) {
162 if (mInteger > 0) {
163 --mInteger;
164 } else {
165 mInteger = 0;
166 mNegative = false;
167 }
168 } else {
169 ++mInteger;
170 }
171 normalize();
172 mFlags |= DLRV_INTEGER_FLAG | DLRV_DECIMAL_FLAG | DLRV_RATIONAL_FLAG;
173 identifyFlags();
174 return this;
175 }
176
177
178
179 CDataLiteralRealValue* CDataLiteralRealValue::initRationalValueFromInteger(cuint64 value, bool negation) {
180 clearValue();
181 mNegative = negation;
182 mInteger = value;
183 normalize();
184 mFlags |= DLRV_INTEGER_FLAG | DLRV_DECIMAL_FLAG | DLRV_RATIONAL_FLAG;
185 identifyFlags();
186 return this;
187 }
188
189
190 CDataLiteralRealValue* CDataLiteralRealValue::initRationalValueFromInteger(cint64 value) {
191 clearValue();
192 if (value < 0) {
193 mNegative = true;
194 mInteger = -value;
195 } else {
196 mNegative = false;
197 mInteger = value;
198 }
199 normalize();
200 mFlags |= DLRV_INTEGER_FLAG | DLRV_DECIMAL_FLAG | DLRV_RATIONAL_FLAG;
201 identifyFlags();
202 return this;
203 }
204
205
206 CDataLiteralRealValue* CDataLiteralRealValue::initValue(CDataLiteralRealValue* value) {
207 clearFlags();
208 if (value) {
209 mInfinite = value->mInfinite;
210 mNegative = value->mNegative;
211 mInteger = value->mInteger;
212 mNumerator = value->mNumerator;
213 mDenominator = value->mDenominator;
214 mFlags = value->mFlags;
215 }
216 return this;
217 }
218
219
220 CDataLiteralRealValue* CDataLiteralRealValue::clearValue() {
221 mInfinite = false;
222 mNegative = false;
223 mInteger = 0;
224 mNumerator = 0;
225 mDenominator = 1;
226 clearFlags();
227 return this;
228 }
229
230 CDataLiteralRealValue* CDataLiteralRealValue::clearFlags() {
231 mFlags = 0;
232 return this;
233 }
234
235 CDataLiteralRealValue* CDataLiteralRealValue::identifyFlags() {
236 mFlags |= DLRV_RATIONAL_FLAG;
237 if (mNumerator == 0) {
238 mFlags |= DLRV_INTEGER_FLAG | DLRV_DECIMAL_FLAG;
239 } else {
240 if (!hasFlag(DLRV_DECIMAL_FLAG)) {
241 cuint64 denominatorFac = mDenominator;
242 bool reduced = false;
243 do {
244 reduced = false;
245 while (denominatorFac % 2 == 0) {
246 denominatorFac /= 2;
247 reduced = true;
248 }
249 if (denominatorFac % 5 == 0) {
250 denominatorFac /= 5;
251 reduced = true;
252 }
253 } while (reduced);
254 if (denominatorFac == 2 || denominatorFac == 5 || denominatorFac == 1) {
255 mFlags |= DLRV_DECIMAL_FLAG;
256 }
257 }
258 }
259 return this;
260 }
261
262
263 cint64 getGreatestCommonDivisor(cint64 u, cint64 v) {
264 cint64 t;
265 while (v) {
266 t = u;
267 u = v;
268 v = t % v;
269 }
270 return u < 0 ? -u : u;
271 }
272
273
274 bool CDataLiteralRealValue::hasFlag(cint64 flag) {
275 return (mFlags & flag) != 0;
276 }
277
278
279 bool CDataLiteralRealValue::normalize() {
280 bool reduced = false;
281 if (mInfinite) {
282 mInteger = 0;
283 mNumerator = 0;
284 mDenominator = 1;
285 }
286 if (mNumerator >= mDenominator) {
287 cint64 nonFraction = mNumerator/mDenominator;
288 mNumerator = mNumerator-nonFraction*mDenominator;
289 mInteger += nonFraction;
290 reduced = true;
291 }
292 if (mNumerator == 0) {
293 mDenominator = 1;
294 } else {
295 cint64 gcd = getGreatestCommonDivisor(mNumerator,mDenominator);
296 if (gcd > 1) {
297 mNumerator = mNumerator/gcd;
298 mDenominator = mDenominator/gcd;
299 reduced = true;
300 }
301 }
302 if (mInteger == 0 && mNumerator == 0 && mNegative && !mInfinite) {
303 mNegative = false;
304 }
305 return reduced;
306 }
307
308
309 bool CDataLiteralRealValue::isNegative() {
310 return mNegative;
311 }
312
313 bool CDataLiteralRealValue::isInfinite() {
314 return mInfinite;
315 }
316
317
318 bool CDataLiteralRealValue::isInfiniteBigNumber() {
319 if (mInfinite) {
320 return true;
321 }
322 if (mNegative && mInteger > Q_INT64_C(9223372036854775808)) {
323 return true;
324 } else if (!mNegative && mInteger > Q_INT64_C(9223372036854775807)) {
325 return true;
326 }
327 return false;
328 }
329
330 cuint64 CDataLiteralRealValue::getInteger() {
331 return mInteger;
332 }
333
334 cuint64 CDataLiteralRealValue::getNumerator() {
335 return mNumerator;
336 }
337
338 cuint64 CDataLiteralRealValue::getDenominator() {
339 return mDenominator;
340 }
341
342
343 cint64 CDataLiteralRealValue::getPosNegInteger() {
344 if (!mNegative) {
345 return mInteger;
346 } else {
347 return -mInteger;
348 }
349 }
350
351
352 CDataLiteralRealValue* CDataLiteralRealValue::setNegative(bool negative) {
353 mNegative = negative;
354 return this;
355 }
356
357 CDataLiteralRealValue* CDataLiteralRealValue::setInteger(cuint64 integer) {
358 mInteger = integer;
359 return this;
360 }
361
362 CDataLiteralRealValue* CDataLiteralRealValue::setNumerator(cuint64 numerator) {
363 mNumerator = numerator;
364 return this;
365 }
366
367 CDataLiteralRealValue* CDataLiteralRealValue::setDenominator(cuint64 denominator) {
368 mDenominator = denominator;
369 return this;
370 }
371
372
373
374
375 bool CDataLiteralRealValue::isEqualTo(CDataLiteralValue* value) {
376 CDataLiteralRealValue* realValue = dynamic_cast<CDataLiteralRealValue*>(value);
377 if (realValue) {
378 return isEqualTo(realValue);
379 }
380 return false;
381 }
382
383
384
385 bool CDataLiteralRealValue::isLessEqualThan(CDataLiteralCompareValue* value) {
386 CDataLiteralRealValue* realValue = dynamic_cast<CDataLiteralRealValue*>(value);
387 if (realValue) {
388 return isEqualTo(realValue) || isLessThan(realValue);
389 }
390 return false;
391 }
392
393 bool CDataLiteralRealValue::isLessEqualThan(CDataLiteralRealValue* realValue) {
394 return isEqualTo(realValue) || isLessThan(realValue);
395 }
396
397
398 bool CDataLiteralRealValue::isEqualTo(CDataLiteralCompareValue* value) {
399 CDataLiteralRealValue* realValue = dynamic_cast<CDataLiteralRealValue*>(value);
400 if (realValue) {
401 return isEqualTo(realValue);
402 }
403 return false;
404 }
405
406 bool CDataLiteralRealValue::isEqualTo(CDataLiteralRealValue* realValue) {
407 if (mNegative == realValue->mNegative) {
408 if (mInfinite && realValue->mInfinite) {
409 return true;
410 }
411 if (mInteger == realValue->mInteger) {
412 if (mNumerator == realValue->mNumerator) {
413 if (mDenominator == realValue->mDenominator) {
414 return true;
415 }
416 }
417 }
418 }
419 return false;
420 }
421
422 bool CDataLiteralRealValue::isGreaterEqualThan(CDataLiteralRealValue* realValue) {
423 return isEqualTo(realValue) || isGreaterThan(realValue);
424 }
425
426 bool CDataLiteralRealValue::isGreaterEqualThan(CDataLiteralCompareValue* value) {
427 CDataLiteralRealValue* realValue = dynamic_cast<CDataLiteralRealValue*>(value);
428 if (realValue) {
429 return isEqualTo(realValue) || isGreaterThan(realValue);
430 }
431 return false;
432 }
433
434 bool CDataLiteralRealValue::isGreaterThan(CDataLiteralCompareValue* value) {
435 return value->isLessThan(this);
436 }
437
438 bool CDataLiteralRealValue::isGreaterThan(CDataLiteralRealValue* realValue) {
439 return realValue->isLessThan(this);
440 }
441
442
443 bool CDataLiteralRealValue::isLessThan(CDataLiteralCompareValue* value) {
444 CDataLiteralRealValue* realValue = dynamic_cast<CDataLiteralRealValue*>(value);
445 if (realValue) {
446 return isLessThan(realValue);
447 }
448 return false;
449 }
450
451
452
453
454
455 bool CDataLiteralRealValue::isLessThan(CDataLiteralRealValue* realValue) {
456 if (mNegative == realValue->mNegative && mInfinite && realValue->mInfinite) {
457 return false;
458 } else if (mNegative && mInfinite) {
459 return true;
460 } else if (!mNegative && mInfinite) {
461 return false;
462 } else if (!realValue->mNegative && realValue->mInfinite) {
463 return true;
464 } else if (realValue->mNegative && realValue->mInfinite) {
465 return false;
466 } else if (mNegative && !realValue->mNegative) {
467 return true;
468 } else if (!mNegative && realValue->mNegative) {
469 return false;
470 }
471 if (mNegative) {
472 if (mInteger > realValue->mInteger) {
473 return true;
474 } else if (mInteger < realValue->mInteger) {
475 return false;
476 } else {
477 if (mDenominator == realValue->mDenominator) {
478 if (mNumerator > realValue->mNumerator) {
479 return true;
480 }
481 } else {
482 cint64 ad = mNumerator*realValue->mDenominator;
483 cint64 bc = realValue->mNumerator*mDenominator;
484 if (ad > bc) {
485 return true;
486 }
487 }
488 }
489 } else {
490 if (mInteger < realValue->mInteger) {
491 return true;
492 } else if (mInteger > realValue->mInteger) {
493 return false;
494 } else {
495 if (mDenominator == realValue->mDenominator) {
496 if (mNumerator < realValue->mNumerator) {
497 return true;
498 }
499 } else {
500 cint64 ad = mNumerator*realValue->mDenominator;
501 cint64 bc = realValue->mNumerator*mDenominator;
502 if (ad < bc) {
503 return true;
504 }
505 }
506 }
507 }
508 return false;
509 }
510
511
512
513 }; // end namespace Ontology
514
515 }; // end namespace Reasoner
516
517 }; // end namespace Konclude