541 lines
13 KiB
C++
541 lines
13 KiB
C++
|
/*
|
||
|
|
----
|
||
|
|
This file is part of SECONDO.
|
||
|
|
|
||
|
|
Copyright (C) 2013, University in Hagen,
|
||
|
|
Faculty of Mathematics and Computer Science,
|
||
|
|
Database Systems for New Applications.
|
||
|
|
|
||
|
|
SECONDO is free software; you can redistribute it and/or modify
|
||
|
|
it under the terms of the GNU General Public License as published by
|
||
|
|
the Free Software Foundation; either version 2 of the License, or
|
||
|
|
(at your option) any later version.
|
||
|
|
|
||
|
|
SECONDO is distributed in the hope that it will be useful,
|
||
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
|
|
GNU General Public License for more details.
|
||
|
|
|
||
|
|
You should have received a copy of the GNU General Public License
|
||
|
|
along with SECONDO; if not, write to the Free Software
|
||
|
|
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
||
|
|
----
|
||
|
|
|
||
|
|
//paragraph [1] Title: [{\Large \bf \begin {center}] [\end {center}}]
|
||
|
|
//[TOC] [\tableofcontents]
|
||
|
|
//[_] [\_]
|
||
|
|
|
||
|
|
[1] File RegionTools2.h
|
||
|
|
|
||
|
|
This file contains functions handling with regions of the Region2-Algebra and
|
||
|
|
the MovingRegion3-Algebra.
|
||
|
|
|
||
|
|
[TOC]
|
||
|
|
|
||
|
|
1 Conversion functions for GMP-type mpq\_class
|
||
|
|
|
||
|
|
1.1 Function ~gmpTypeToTextType1()~
|
||
|
|
|
||
|
|
Reads from inValue and stores its representation as TextType in resultList.
|
||
|
|
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include "Region2Tools.h"
|
||
|
|
using namespace std;
|
||
|
|
|
||
|
|
void gmpTypeToTextType1
|
||
|
|
(const mpq_class& inValue, ListExpr& resultList) {
|
||
|
|
stringstream theStream;
|
||
|
|
theStream << inValue;
|
||
|
|
resultList = nl->TextAtom();
|
||
|
|
|
||
|
|
string st = theStream.str();
|
||
|
|
nl->AppendText(resultList, st);
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
1.1 Function ~gmpTypeToTextType2()~
|
||
|
|
|
||
|
|
Reads from inValue and stores its representation as TextType in resultList.
|
||
|
|
|
||
|
|
*/
|
||
|
|
void gmpTypeToTextType2 (const mpq_class& inValue, ListExpr& resultList)
|
||
|
|
{
|
||
|
|
stringstream theStream;
|
||
|
|
mpf_class helper(inValue,1024);
|
||
|
|
|
||
|
|
theStream << setprecision(1024) << helper;
|
||
|
|
resultList = nl->TextAtom(theStream.str());
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
1.1 Function ~textTypeToGmpType1()~
|
||
|
|
|
||
|
|
Reads from inList and stores its representation as mpq\_class in outValue.
|
||
|
|
|
||
|
|
*/
|
||
|
|
void textTypeToGmpType1
|
||
|
|
(const ListExpr& inList, mpq_class& outValue) {
|
||
|
|
|
||
|
|
TextScan theScan = nl->CreateTextScan(inList);
|
||
|
|
stringstream theStream;
|
||
|
|
|
||
|
|
char lastChar = '*'; //just a random initialization...
|
||
|
|
|
||
|
|
for (unsigned int i = 0; i < nl->TextLength(inList); i++)
|
||
|
|
{
|
||
|
|
string str = "";
|
||
|
|
nl->GetText(theScan, 1, str);
|
||
|
|
|
||
|
|
//Checking for valid character
|
||
|
|
if ((int)str[0] < 47 || (int)str[0] > 57
|
||
|
|
|| (i == 0 && (int)str[0] == 48
|
||
|
|
&& nl->TextLength(inList) > 1)
|
||
|
|
|| (lastChar == '/' && (int)str[0] == 48))
|
||
|
|
{
|
||
|
|
stringstream message;
|
||
|
|
message << "Precise coordinate not valid: "
|
||
|
|
<< nl->ToString(inList)
|
||
|
|
<< endl << "Only characters 1, 2, 3, 4, 5, "
|
||
|
|
"6, 7, 8, 9, 0 and / allowed." << endl
|
||
|
|
<< "0 mustn't be leading "
|
||
|
|
"character when "
|
||
|
|
"more than one character "
|
||
|
|
"in total are given"
|
||
|
|
<< endl << ", and 0 is "
|
||
|
|
"not allowed directly after /";
|
||
|
|
throw invalid_argument(message.str());
|
||
|
|
}
|
||
|
|
|
||
|
|
theStream.put(str[0]);
|
||
|
|
lastChar = str[0];
|
||
|
|
}
|
||
|
|
|
||
|
|
theStream >> outValue;
|
||
|
|
|
||
|
|
outValue.canonicalize();
|
||
|
|
|
||
|
|
if (cmp(outValue, 1) >= 0 || cmp(outValue,0) < 0)
|
||
|
|
{
|
||
|
|
stringstream message;
|
||
|
|
message << "Precise coordinate not valid: "
|
||
|
|
<< nl->ToString(inList)
|
||
|
|
<< endl
|
||
|
|
<< "Resulting value is not between 0 and 1, "
|
||
|
|
"where 0 is allowed, but 1 is not.";
|
||
|
|
throw invalid_argument(message.str());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
1.1 Function ~textTypeToGmpType2()~
|
||
|
|
|
||
|
|
Reads from inList and stores its representation as mpq\_class in outValue.
|
||
|
|
|
||
|
|
*/
|
||
|
|
void textTypeToGmpType2
|
||
|
|
(const ListExpr& inList, mpq_class& outValue) {
|
||
|
|
|
||
|
|
TextScan theScan = nl->CreateTextScan(inList);
|
||
|
|
stringstream numStream, denStream;
|
||
|
|
bool denStart = false;
|
||
|
|
denStream.put('1');
|
||
|
|
|
||
|
|
for (unsigned int i = 0; i < nl->TextLength(inList); i++)
|
||
|
|
{
|
||
|
|
string str = "";
|
||
|
|
nl->GetText(theScan, 1, str);
|
||
|
|
//Checking for valid character
|
||
|
|
// CHECK FOR +/- 3.4e +/- 38 (~7 digits) ????
|
||
|
|
if ( (int)str[0] < 43 || (int)str[0] > 57
|
||
|
|
|| (int)str[0] == 47 || (int)str[0] == 44
|
||
|
|
|| ((i != 0 || nl->TextLength(inList) == 1)
|
||
|
|
&& ((int)str[0] == 43 || (int)str[0] == 45)) )
|
||
|
|
{
|
||
|
|
stringstream message;
|
||
|
|
message << "Precise coordinate not valid: "
|
||
|
|
<< nl->ToString(inList)
|
||
|
|
<< endl << "Only characters 1, 2, 3, 4, 5, "
|
||
|
|
"6, 7, 8, 9, 0 and . allowed." << endl
|
||
|
|
<< "+/- must be leading "
|
||
|
|
"character when "
|
||
|
|
"more than one character "
|
||
|
|
"in total are given" << endl;
|
||
|
|
throw invalid_argument(message.str());
|
||
|
|
}
|
||
|
|
|
||
|
|
if (denStart) denStream.put('0');
|
||
|
|
if ((int)str[0] != 46) numStream.put(str[0]);
|
||
|
|
else
|
||
|
|
{
|
||
|
|
denStart = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
outValue = mpq_class(mpz_class(numStream.str()),
|
||
|
|
mpz_class(denStream.str()));
|
||
|
|
outValue.canonicalize();
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
1.1 Function ~D2MPQ()~
|
||
|
|
|
||
|
|
Converts value of type double to a value of type mpq\_class
|
||
|
|
|
||
|
|
*/
|
||
|
|
mpq_class D2MPQ( const double d )
|
||
|
|
{
|
||
|
|
mpq_class res = mpq_class(d);
|
||
|
|
|
||
|
|
stringstream s, numStream, denStream;
|
||
|
|
bool denStart = false;
|
||
|
|
denStream.put('1');
|
||
|
|
|
||
|
|
s << setprecision(16) << d;
|
||
|
|
if (s.str().find("E") == string::npos
|
||
|
|
&& s.str().find("e") == string::npos)
|
||
|
|
{
|
||
|
|
for (unsigned int i = 0; i < s.str().length(); i++)
|
||
|
|
{
|
||
|
|
if (denStart) denStream.put('0');
|
||
|
|
if ((int)s.str()[i] != 46) numStream.put(s.str()[i]);
|
||
|
|
else
|
||
|
|
{
|
||
|
|
denStart = true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
res = mpq_class(mpz_class(numStream.str(), 10),
|
||
|
|
mpz_class(denStream.str(), 10));
|
||
|
|
res.canonicalize();
|
||
|
|
}
|
||
|
|
|
||
|
|
return res;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
1 Functions to write the precise values to and read them from the DbArray
|
||
|
|
|
||
|
|
1.1 Function ~SetValueX()~
|
||
|
|
|
||
|
|
Stores value z of type mpz\_class in DbArray of type unsigned int, gives back the startposition and
|
||
|
|
the number of used unsigned int-values
|
||
|
|
|
||
|
|
*/
|
||
|
|
void SetValueX(mpz_class z, DbArray<unsigned int>* preciseValuesArray,
|
||
|
|
int& startpos, int& numofInt)
|
||
|
|
{
|
||
|
|
if (cmp(z, 0) < 0) return;
|
||
|
|
|
||
|
|
if (startpos == -1)
|
||
|
|
startpos = preciseValuesArray->Size();
|
||
|
|
int index = startpos;
|
||
|
|
if (index >= preciseValuesArray->Size())
|
||
|
|
preciseValuesArray->resize(index+1);
|
||
|
|
numofInt = 0;
|
||
|
|
|
||
|
|
mpz_class zdiv(numeric_limits<unsigned int>::max());
|
||
|
|
zdiv++;
|
||
|
|
mpz_class w(0);
|
||
|
|
while ( !(cmp(z, 0) == 0) )
|
||
|
|
{
|
||
|
|
w = z%zdiv;
|
||
|
|
unsigned int wert = (unsigned int)w.get_ui();
|
||
|
|
preciseValuesArray->Put(index, wert);
|
||
|
|
index++;
|
||
|
|
numofInt++;
|
||
|
|
z = z/zdiv;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
1.1 Function ~GetValueX()~
|
||
|
|
|
||
|
|
Reads value of type mpz\_class from DbArray of type unsigned int, starting at startposition and
|
||
|
|
with number of used unsigned int-values
|
||
|
|
|
||
|
|
*/
|
||
|
|
mpz_class GetValueX(const int startpos, const int numofInt,
|
||
|
|
const DbArray<unsigned int>* preciseValuesArray)
|
||
|
|
{
|
||
|
|
mpz_class theValue(0);
|
||
|
|
mpz_class zdiv(numeric_limits<unsigned int>::max());
|
||
|
|
zdiv++;
|
||
|
|
unsigned int wert;
|
||
|
|
|
||
|
|
for (int i = startpos + numofInt-1; i >= startpos; i--)
|
||
|
|
{
|
||
|
|
preciseValuesArray->Get(i, wert);
|
||
|
|
theValue = theValue*zdiv + wert;
|
||
|
|
}
|
||
|
|
return theValue;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
1 Functions to detect an overflow of integer values
|
||
|
|
|
||
|
|
1.1 Function ~overflowAsInt~
|
||
|
|
|
||
|
|
checks int-overflow of x1 or x2 with scalefactor s
|
||
|
|
|
||
|
|
*/
|
||
|
|
bool overflowAsInt(mpq_class x1, mpq_class x2, int s )
|
||
|
|
{
|
||
|
|
mpz_t sFactor;
|
||
|
|
mpz_init(sFactor);
|
||
|
|
mpq_class sFac(0);
|
||
|
|
uint sfactor;
|
||
|
|
mpz_class zdiv;
|
||
|
|
mpq_class quot;
|
||
|
|
|
||
|
|
if (s < 0)
|
||
|
|
{
|
||
|
|
sfactor = -s;
|
||
|
|
mpz_ui_pow_ui(sFactor, 10, sfactor);
|
||
|
|
sFac = mpq_class(mpz_class(1), mpz_class(sFactor));
|
||
|
|
}
|
||
|
|
else if (s > 0)
|
||
|
|
{
|
||
|
|
sfactor = s;
|
||
|
|
mpz_ui_pow_ui(sFactor, 10, sfactor);
|
||
|
|
sFac = mpq_class(mpz_class(sFactor), mpz_class(1));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
sFac = mpq_class(1);
|
||
|
|
sFac.canonicalize();
|
||
|
|
mpz_clear(sFactor);
|
||
|
|
|
||
|
|
if (cmp(x1, 0) > 0)
|
||
|
|
{
|
||
|
|
x1 = x1*sFac;
|
||
|
|
zdiv = mpz_class(numeric_limits<int>::max())+1;
|
||
|
|
quot = x1 / zdiv;
|
||
|
|
quot.canonicalize();
|
||
|
|
if (cmp(quot, 1) >= 0)
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (cmp(x1, 0) < 0)
|
||
|
|
{
|
||
|
|
x1 = x1*sFac;
|
||
|
|
zdiv = mpz_class(numeric_limits<int>::min())-1;
|
||
|
|
quot = x1 / zdiv;
|
||
|
|
quot.canonicalize();
|
||
|
|
if (cmp(quot, 1) >= 0)
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (cmp(x2, 0) > 0)
|
||
|
|
{
|
||
|
|
x2 = x2*sFac;
|
||
|
|
zdiv = mpz_class(numeric_limits<int>::max())+1;
|
||
|
|
quot = x2 / zdiv;
|
||
|
|
quot.canonicalize();
|
||
|
|
if (cmp(quot, 1) >= 0)
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (cmp(x2, 0) < 0)
|
||
|
|
{
|
||
|
|
x2 = x2*sFac;
|
||
|
|
zdiv = mpz_class(numeric_limits<int>::min())-1;
|
||
|
|
quot = x2 / zdiv;
|
||
|
|
quot.canonicalize();
|
||
|
|
if (cmp(quot, 1) >= 0)
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
1.1 Function ~overflowAsInt~
|
||
|
|
|
||
|
|
checks int-overflow of x1 or x2 by scaling with s
|
||
|
|
|
||
|
|
*/
|
||
|
|
bool overflowAsInt(mpq_class x1, mpq_class x2, double s)
|
||
|
|
{
|
||
|
|
if (s == 1.0)
|
||
|
|
return false;
|
||
|
|
|
||
|
|
mpq_class sFac(s);
|
||
|
|
mpz_class zdiv;
|
||
|
|
mpq_class quot;
|
||
|
|
|
||
|
|
if (cmp(x1, 0) > 0 && s > 1.0)
|
||
|
|
{
|
||
|
|
x1 = x1*sFac;
|
||
|
|
zdiv = mpz_class(numeric_limits<int>::max())+1;
|
||
|
|
quot = x1 / zdiv;
|
||
|
|
quot.canonicalize();
|
||
|
|
if (cmp(quot, 1) >= 0)
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (cmp(x1, 0) > 0 && s < -1.0)
|
||
|
|
{
|
||
|
|
x1 = x1*sFac;
|
||
|
|
zdiv = mpz_class(numeric_limits<int>::min())-1;
|
||
|
|
quot = x1 / zdiv;
|
||
|
|
quot.canonicalize();
|
||
|
|
if (cmp(quot, 1) >= 0)
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (cmp(x1, 0) < 0 && s > 1.0)
|
||
|
|
{
|
||
|
|
x1 = x1*sFac;
|
||
|
|
zdiv = mpz_class(numeric_limits<int>::min())-1;
|
||
|
|
quot = x1 / zdiv;
|
||
|
|
quot.canonicalize();
|
||
|
|
if (cmp(quot, 1) >= 0)
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (cmp(x1, 0) < 0 && s < -1.0)
|
||
|
|
{
|
||
|
|
x1 = x1*sFac;
|
||
|
|
zdiv = mpz_class(numeric_limits<int>::max())+1;
|
||
|
|
quot = x1 / zdiv;
|
||
|
|
quot.canonicalize();
|
||
|
|
if (cmp(quot, 1) >= 0)
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (cmp(x2, 0) > 0 && s > 1.0)
|
||
|
|
{
|
||
|
|
x2 = x2*sFac;
|
||
|
|
zdiv = mpz_class(numeric_limits<int>::max())+1;
|
||
|
|
quot = x2 / zdiv;
|
||
|
|
quot.canonicalize();
|
||
|
|
if (cmp(quot, 1) >= 0)
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (cmp(x2, 0) > 0 && s < -1.0)
|
||
|
|
{
|
||
|
|
x2 = x2*sFac;
|
||
|
|
zdiv = mpz_class(numeric_limits<int>::min())-1;
|
||
|
|
quot = x2 / zdiv;
|
||
|
|
quot.canonicalize();
|
||
|
|
if (cmp(quot, 1) >= 0)
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (cmp(x2, 0) < 0 && s > 1.0)
|
||
|
|
{
|
||
|
|
x2 = x2*sFac;
|
||
|
|
zdiv = mpz_class(numeric_limits<int>::min())-1;
|
||
|
|
quot = x2 / zdiv;
|
||
|
|
quot.canonicalize();
|
||
|
|
if (cmp(quot, 1) >= 0)
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (cmp(x2, 0) < 0 && s < -1.0)
|
||
|
|
{
|
||
|
|
x2 = x2*sFac;
|
||
|
|
zdiv = mpz_class(numeric_limits<int>::max())+1;
|
||
|
|
quot = x2 / zdiv;
|
||
|
|
quot.canonicalize();
|
||
|
|
if (cmp(quot, 1) >= 0)
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
1.1 Function ~checkFactorOverflow~
|
||
|
|
|
||
|
|
checks int-overflow of maxI or minI with scalefactor s
|
||
|
|
|
||
|
|
*/
|
||
|
|
bool checkFactorOverflow(int maxI, int minI, int s )
|
||
|
|
{
|
||
|
|
if (s <= 0 || (maxI == 0 && minI == 0))
|
||
|
|
return false;
|
||
|
|
|
||
|
|
mpz_t sFactor;
|
||
|
|
mpz_init(sFactor);
|
||
|
|
mpq_class sFac(0);
|
||
|
|
uint sfactor;
|
||
|
|
mpz_class zdiv;
|
||
|
|
mpq_class quot;
|
||
|
|
mpz_class x;
|
||
|
|
|
||
|
|
sfactor = s;
|
||
|
|
mpz_ui_pow_ui(sFactor, 10, sfactor);
|
||
|
|
sFac = mpq_class(mpz_class(sFactor), mpz_class(1));
|
||
|
|
sFac.canonicalize();
|
||
|
|
mpz_clear(sFactor);
|
||
|
|
|
||
|
|
if (maxI > 0)
|
||
|
|
{
|
||
|
|
x = mpz_class(maxI);
|
||
|
|
zdiv = mpz_class(numeric_limits<int>::max());
|
||
|
|
quot = x * sFac / zdiv;
|
||
|
|
quot.canonicalize();
|
||
|
|
if (cmp(quot, 1) > 0)
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (minI < 0)
|
||
|
|
{
|
||
|
|
x = mpz_class(minI);
|
||
|
|
zdiv = mpz_class(numeric_limits<int>::min());
|
||
|
|
quot = x * sFac / zdiv;
|
||
|
|
quot.canonicalize();
|
||
|
|
if (cmp(quot, 1) > 0)
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
/*
|
||
|
|
1.1 Function ~checkFactorOverflow~
|
||
|
|
|
||
|
|
checks int-overflow of maxI or minI by scaling with s
|
||
|
|
|
||
|
|
*/
|
||
|
|
bool checkFactorOverflow(int maxI, int minI, double s )
|
||
|
|
{
|
||
|
|
if (s == 1.0 || (maxI == 0 && minI == 0))
|
||
|
|
return false;
|
||
|
|
|
||
|
|
mpq_class sFac(s);
|
||
|
|
mpz_class zdiv;
|
||
|
|
mpq_class quot;
|
||
|
|
mpz_class x;
|
||
|
|
|
||
|
|
if (maxI > 0 && s > 1.0)
|
||
|
|
{
|
||
|
|
x = mpz_class(maxI);
|
||
|
|
zdiv = mpz_class(numeric_limits<int>::max());
|
||
|
|
quot = x * sFac / zdiv;
|
||
|
|
quot.canonicalize();
|
||
|
|
if (cmp(quot, 1) > 0)
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (maxI > 0 && s < -1.0)
|
||
|
|
{
|
||
|
|
x = mpz_class(maxI);
|
||
|
|
zdiv = mpz_class(numeric_limits<int>::min());
|
||
|
|
quot = x * sFac / zdiv;
|
||
|
|
quot.canonicalize();
|
||
|
|
if (cmp(quot, 1) > 0)
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (minI < 0 && s > 1.0)
|
||
|
|
{
|
||
|
|
x = mpz_class(minI);
|
||
|
|
zdiv = mpz_class(numeric_limits<int>::min());
|
||
|
|
quot = x * sFac / zdiv;
|
||
|
|
quot.canonicalize();
|
||
|
|
if (cmp(quot, 1) > 0)
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
if (minI < 0 && s < -1.0)
|
||
|
|
{
|
||
|
|
x = mpz_class(minI);
|
||
|
|
zdiv = mpz_class(numeric_limits<int>::max());
|
||
|
|
quot = x * sFac / zdiv;
|
||
|
|
quot.canonicalize();
|
||
|
|
if (cmp(quot, 1) > 0)
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
}
|