int gomori::findMaxFractionalPart(vector<float> vec) {
unsigned s = vec.size();
int ind = 0;
float max = fractionalPart(vec[0]);
for (unsigned i = 1; i < s; i++) {
if (fractionalPart(vec[i]) > max) {
max = fractionalPart(vec[i]);
ind = i;
}
}
return ind;
}
float gomori::fractionalPart(float n) {
if (abs(n) < 0.00001) return 0;
if(n> 0) return (n - (int)roundF(n));
if (fractionalPart(abs(n)) < 0.000001f) return 0;
else return (n - (int)roundF(n - 1));
}
// adds new restriction into simplex system
// the restriction is based on followed line with index n
void gomori::addRestriction(int n, Data* data) {
data->freeMembers.push_back(-fractionalPart(data->freeMembers[n]));
vector<float> newRow;
for (unsigned i = 0; i < data->system[n].size(); i++)
newRow.push_back( -fractionalPart(data->system[n][i]));
//adding new element into base
newRow.push_back(1);
data->base.push_back(newRow.size()); // stores the number of base element
//resizing of simplex system
data->coefficients.push_back(0);
for (unsigned i = 0; i < data->system.size(); i++)
data->system[i].push_back(0);
data->system.push_back(newRow);
}
bool gomori::checkIsOver(Data* data) {
unsigned s = data->freeMembers.size();
for (unsigned i = 0; i < s; i++) {
if (fractionalPart(data->freeMembers[i]) > 0.0001)
return false;
}
return true;
}
char* convertDoubleToString(double x, int fractionalPartLength) {
int truncated = (int)x;
int fractional = fractionalPart(x, fractionalPartLength);
char* truncatedString = convertIntToString(truncated);
char* fractionalString = convertIntToString(fractional);
char* string = stringConcat3(truncatedString, ".", fractionalString);
free(truncatedString);
free(fractionalString);
return string;
}
TestResult* fractionalPartTestNegativeNumber() {
double x = -123.123;
int length = 2;
int expected = 12;
int actual = fractionalPart(x, length);
TestResult* r = malloc(sizeof(TestResult));
r -> testName = "fractionalPartTestNegativeNumber";
r -> passed = areIntEqual(actual, expected);
return r;
}
void GlslSymbol::writeFloat(std::stringstream &out, float f)
{
static char buffer[64];
if (fractionalPart(f) == 0.f)
sprintf(buffer, "%.1f", f);
else
sprintf(buffer, "%.*g", FLT_DIG, f);
out << buffer;
}
static bool floatToken(Token &x) {
const char *begin = save();
if (!sign()) restore(begin);
const char *afterSign = save();
if (hexInt()) {
const char *p = save();
if (hexFractionalPart()) {
if (!hexExponentPart())
return false;
} else {
restore(p);
if (!hexExponentPart())
return false;
}
const char *end = save();
x = Token(T_FLOAT_LITERAL, llvm::StringRef(begin, end-begin));
return true;
} else {
restore(afterSign);
if (decimalInt()) {
const char *p = save();
if (fractionalPart()) {
p = save();
if (!exponentPart())
restore(p);
} else {
restore(p);
if (!exponentPart())
return false;
}
const char *end = save();
x = Token(T_FLOAT_LITERAL, llvm::StringRef(begin, end-begin));
return true;
} else
return false;
}
}
bool Solver::iterateInt()
{
if(m_status != OptimalSolutionFound)
return false;
size_t cuti = m_height;
for(size_t i=0; i < m_height; i++)
{
if(LimitCutoff == m_limitType[i] && m_columnB[i] < 0)
{
cuti = i;
break;
}
}
// basis changing
if(cuti != m_height)
{
size_t minj = m_width;
/* double minTheta = std::numeric_limits<double>::infinity(); */
for(size_t j=0; j < m_width; j++)
{
if(m_matrixA[cuti][j] < 0)
{
minj = j;
break;
/*
FIXME: very slow
double theta = m_columnB[cuti] / m_matrixA[cuti][j];
if(theta < minTheta)
{
minj = j;
minTheta = theta;
}
*/
// TODO: equals check
}
}
// qDebug() << "minj" << minj << "; cuti " << cuti;
if(minj == m_width)
{
m_status = SolutionNotExists;
return true;
}
m_maxj = minj;
m_mini = cuti;
changeBasis();
m_F = 0.0;
for(size_t i=0; i < m_height; i++)
{
m_F += m_columnB[i] * m_rowC[m_columnBasis[i]];
}
return true;
}
for(size_t i=0; i < m_height; i++)
{
if(!m_variableInt[m_columnBasis[i]])
continue;
if(!isInteger(m_columnB[i]))
{
// make goomory cutoff
m_rowC.push_back(0.0);
m_rowD.push_back(0.0);
m_rowWD.push_back(0.0);
m_variableInt.push_back(false);
m_variableType.push_back(VariableCutoff);
for(size_t ii=0; ii < m_height; ii++)
m_matrixA[ii].push_back(0.0);
// add limit
std::vector<double> tmp(m_width, 0);
for(size_t j=0; j < m_width; j++)
tmp[j] = -fractionalPart(m_matrixA[i][j]);
tmp.push_back(1.0);
m_matrixA.push_back(tmp);
m_columnCompareOp.push_back(Equal);
m_columnTheta.push_back(0.0);
m_columnB.push_back(-fractionalPart(m_columnB[i]));
m_columnBasis.push_back(m_width);
m_limitType.push_back(LimitCutoff);
m_width++;
m_height++;
return true;
}
}
m_status = OptimalIntSolutionFound;
return true;
}
