/* In stem(p,i,j), p is a char pointer, and the string to be stemmed is from
p[i] to p[j] inclusive. Typically i is zero and j is the offset to the last
character of a string, (p[j+1] == '\0'). The stemmer adjusts the
characters p[i] ... p[j] and returns the new end-point of the string, k.
Stemming never increases word length, so i <= k <= j. To turn the stemmer
into a module, declare 'stem' as extern, and delete the remainder of this
file.
*/
static ssize_t
stem(char *s, size_t z)
{
/* copy the parameters into statics */
b = s;
k = z - 1;
k0 = 0;
if (k <= k0 + 1) {
/*-DEPARTURE-*/
return k;
}
/* With this line, strings of length 1 or 2 don't go through the
stemming process, although no mention is made of this in the
published algorithm. Remove the line to match the published
algorithm. */
step1ab();
step1c();
step2();
step3();
step4();
step5();
return k;
}
static size_t stem(char *p, size_t i, size_t j) {
b = p;
k = j;
k0 = i; /* copy the parameters into statics */
/*
* DEPARTURE: This next 'if' statement prevents strings of length 1 or 2 from
* going through the stemming process, although no mention is made of this in the
* published algorithm. Remove the line to match the publishedalgorithm.
*/
if (k <= k0 + 1)
return k;
step1ab();
if (k > k0) {
step1c();
step2();
step3();
step4();
step5();
}
return k;
}
/* In `stem(p, i, j)`, `p` is a `char` pointer, and the
* string to be stemmed is from `p[i]` to
* `p[j]` (inclusive).
*
* Typically, `i` is zero and `j` is the offset to the
* last character of a string, `(p[j + 1] == '\0')`.
* The stemmer adjusts the characters `p[i]` ... `p[j]`
* and returns the new end-point of the string, `k`.
*
* Stemming never increases word length, so `i <= k <= j`.
*
* To turn the stemmer into a module, declare 'stem' as
* extern, and delete the remainder of this file. */
int
stem(char *p, int index, int position) {
/* Copy the parameters into statics. */
b = p;
k = position;
k0 = index;
if (k <= k0 + 1) {
return k; /* --DEPARTURE-- */
}
/* With this line, strings of length 1 or 2 don't
* go through the stemming process, although no
* mention is made of this in the published
* algorithm. Remove the line to match the published
* algorithm. */
step1ab();
if (k > k0) {
step1c();
step2();
step3();
step4();
step5();
}
return k;
}
void Munkres::step4() {
/* find an uncovered zero and prime it
* if now starred zeros in row goto step 5
* else cover row and uncover colum of starred zero
*
* once no uncovered exist goto step 6.
*/
bool done = false;
int i = 0;
int j = 0;
int a;
while (!done) {
if (find_zero(&i, &j)) {
if (!is_covered(i, j)) {
prime(i, j);
a = starred_in_row(i);
if (a == -1) // if no starred zeros
{
done = true;
step5(i, j);
} else {
uncover_col(a);
cover_row(i);
}
}
} else {
done = true;
step6( min_uncovered());
}
}
}
String BrazilianStemmer::stem(const String& term)
{
// creates CT
createCT(term);
if (!isIndexable(CT))
return L"";
if (!isStemmable(CT))
return CT;
R1 = getR1(CT);
R2 = getR1(R1);
RV = getRV(CT);
TERM = term + L";" + CT;
bool altered = step1();
if (!altered)
altered = step2();
if (altered)
step3();
else
step4();
step5();
return CT;
}
int stem(char * p, int i, int j)
{ b = p; k = j; k0 = i; /* copy the parameters into statics */
if (k <= k0+1) return k; /*-DEPARTURE-*/
/* With this line, strings of length 1 or 2 don't go through the
stemming process, although no mention is made of this in the
published algorithm. Remove the line to match the published
algorithm. */
step1ab(); step1c(); step2(); step3(); step4(); step5();
return k;
}
extern int stem_ts(struct stemmer * z, char * b, int k)
{
if (k <= 1) return k; /*-DEPARTURE-*/
z->b = b; z->k = k; /* copy the parameters into z */
/* With this line, strings of length 1 or 2 don't go through the
stemming process, although no mention is made of this in the
published algorithm. Remove the line to match the published
algorithm. */
step1ab(z); step1c(z); step2(z); step3(z); step4(z); step5(z);
return z->k;
}
bool PorterStemmer::stem() {
//i = strlen(b);
k = i -1;
k0 = 0;
if (k > k0+1) {
step1(); step2(); step3(); step4(); step5(); step6();
}
// Also, a word is considered dirty if we lopped off letters
// Thanks to Ifigenia Vairelles for pointing this out.
if (i != k+1)
dirty = true;
i = k+1;
return dirty;
}
/* nml: this function slightly modified to not require external stemmer
* structure or length count (accepts NUL-terminated term) */
void stem_porters(void *opaque, char *term) {
struct stemmer z;
z.b = term; z.k = str_len(term) - 1; /* copy the parameters into z */
if (z.k <= 1) return; /*-DEPARTURE-*/
/* With this line, strings of length 1 or 2 don't go through the
stemming process, although no mention is made of this in the
published algorithm. Remove the line to match the published
algorithm. */
step1ab(&z); step1c(&z); step2(&z); step3(&z); step4(&z); step5(&z);
term[z.k + 1] = '\0'; /* zero-terminate string */
}
// --------------------------------------------------------------------------
// Function Name : step3
// Auther : chen chen
// Data : 2016-02-15
// --------------------------------------------------------------------------
void AssignmentProblemSolver::step3(int *assignment, double *distMatrix, bool *starMatrix, bool *newStarMatrix, bool *primeMatrix, bool *coveredColumns, bool *coveredRows, int nOfRows, int nOfColumns, int minDim)
{
bool zerosFound;
int row, col, starCol;
zerosFound = true;
while(zerosFound)
{
zerosFound = false;
for(col = 0; col < nOfColumns; col++)
{
if(!coveredColumns[col])
{
for(row = 0; row < nOfRows; row++)
{
if((!coveredRows[row]) && (distMatrix[row + nOfRows*col] == 0))
{
/* prime zero */
primeMatrix[row + nOfRows*col] = true;
/* find starred zero in current row */
for(starCol = 0; starCol < nOfColumns; starCol++)
if(starMatrix[row + nOfRows*starCol])
{
break;
}
if(starCol == nOfColumns) /* no starred zero found */
{
/* move to step 4 */
step4(assignment, distMatrix, starMatrix, newStarMatrix, primeMatrix, coveredColumns, coveredRows, nOfRows, nOfColumns, minDim, row, col);
return;
}
else
{
coveredRows[row] = true;
coveredColumns[starCol] = false;
zerosFound = true;
break;
}
}
}
}
}
}
/* move to step 5 */
step5(assignment, distMatrix, starMatrix, newStarMatrix, primeMatrix, coveredColumns, coveredRows, nOfRows, nOfColumns, minDim);
}
static void step3(int *ix, int *mdist, mat_t mstar, mat_t nmstar,
mat_t mprime, col_t ccol, col_t crow, int nrows, int ncols,
int dmin)
{
int zerosFound;
int row, col, cstar;
zerosFound = 1;
while (zerosFound) {
zerosFound = 0;
for (col = 0; col < ncols; col++) {
if (GET1(ccol, col))
continue;
for (row = 0; row < nrows; row++) {
if (mdist[row + nrows * col] != 0)
continue;
if (GET1(crow, row))
continue;
/* prime zero */
SET2(mprime, row, col);
/* find starred zero in current row */
for (cstar = 0; cstar < ncols; cstar++)
if (GET2(mstar, row, cstar))
break;
if (cstar == ncols) { /* no starred zero */
/* move to step 4 */
step4(ix, mdist, mstar, nmstar,
mprime, ccol, crow, nrows, ncols,
dmin, row, col);
return;
} else {
SET1(crow, row);
CLEAR1(ccol, cstar);
zerosFound = 1;
break;
}
}
}
}
/* move to step 5 */
step5(ix, mdist, mstar, nmstar,
mprime, ccol, crow, nrows, ncols,
dmin);
}
wchar_t*
s_stem(wchar_t *word) {
wchar_t* copy;
copy = malloc(sizeof(*copy) * (wcslen(word)+1));
wcscpy(copy, word);
step1a(copy);
step1b(copy);
step1c(copy);
step2(copy);
step3(copy);
step4(copy);
step5(copy);
return copy;
}
KuhnMunkres::Indexes KuhnMunkres::calculate(const Grid &grid)
{
grid_ = grid;
const Dimensions dimensions = ensure_grid_is_square();
size = static_cast<int>(grid_.size());
#ifdef USE_STL
row_covered.resize(size, false);
column_covered.resize(size, false);
#else
row_covered.fill(false, size);
column_covered.fill(false, size);
#endif
z0_row = 0;
z0_column = 0;
path = make_grid(size * 2, static_cast<int>(ZERO));
marked = make_grid(size, static_cast<int>(ZERO));
int step = 1;
while (step) {
switch (step) {
case 1: step = step1(); break;
case 2: step = step2(); break;
case 3: step = step3(); break;
case 4: step = step4(); break;
case 5: step = step5(); break;
case 6: step = step6(); break;
default: break;
}
}
Indexes indexes;
for (int row = 0; row < size; ++row) {
for (int column = 0; column < size; ++column) {
if ((row < dimensions.first) &&
(column < dimensions.second) &&
marked.at(row).at(column) == STAR)
#ifdef USE_STL
indexes.push_back(std::make_pair(row, column));
#else
indexes.push_back(qMakePair(row, column));
#endif
}
}
return indexes;
}
void step3(double *assignment, double *distMatrix, char *starMatrix, char *newStarMatrix, char *primeMatrix, char *coveredColumns, char *coveredRows, int nOfRows, int nOfColumns, int minDim)
{
char zerosFound;
int row, col, starCol;
zerosFound = 1;
while(zerosFound)
{
zerosFound = 0;
for(col=0; col<nOfColumns; col++)
if(!coveredColumns[col])
for(row=0; row<nOfRows; row++)
if((!coveredRows[row]) && (distMatrix[row + nOfRows*col] == 0))
{
/* prime zero */
primeMatrix[row + nOfRows*col] = 1;
/* find starred zero in current row */
for(starCol=0; starCol<nOfColumns; starCol++)
if(starMatrix[row + nOfRows*starCol])
break;
if(starCol == nOfColumns) /* no starred zero found */
{
/* move to step 4 */
step4(assignment, distMatrix, starMatrix, newStarMatrix, primeMatrix, coveredColumns, coveredRows, nOfRows, nOfColumns, minDim, row, col);
return;
}
else
{
coveredRows[row] = 1;
coveredColumns[starCol] = 0;
zerosFound = 1;
break;
}
}
}
/* move to step 5 */
step5(assignment, distMatrix, starMatrix, newStarMatrix, primeMatrix, coveredColumns, coveredRows, nOfRows, nOfColumns, minDim);
}
String FrenchStemmer::stem(const String& term)
{
if (!isStemmable(term))
return term;
// Use lowercase for medium stemming.
stringBuffer = StringUtils::toLower(term);
// reset the booleans
modified = false;
suite = false;
treatVowels(stringBuffer);
setStrings();
step1();
if (!modified || suite)
{
if (!RV.empty())
{
suite = step2a();
if (!suite)
step2b();
}
}
if (modified || suite)
step3();
else
step4();
step5();
step6();
return stringBuffer;
}
void
Munkres::solve(Matrix<double> &m) {
// Linear assignment problem solution
// [modifies matrix in-place.]
// matrix(row,col): row major format assumed.
// Assignments are remaining 0 values
// (extra 0 values are replaced with -1)
#ifdef DEBUG
std::cout << "Munkres input matrix:" << std::endl;
for ( int row = 0 ; row < m.rows() ; row++ ) {
for ( int col = 0 ; col < m.columns() ; col++ ) {
std::cout.width(8);
std::cout << m(row,col) << ",";
}
std::cout << std::endl;
}
std::cout << std::endl;
#endif
double highValue = 0;
for ( int row = 0 ; row < m.rows() ; row++ ) {
for ( int col = 0 ; col < m.columns() ; col++ ) {
if ( m(row,col) != INFINITY && m(row,col) > highValue )
highValue = m(row,col);
}
}
highValue++;
for ( int row = 0 ; row < m.rows() ; row++ )
for ( int col = 0 ; col < m.columns() ; col++ )
if ( m(row,col) == INFINITY )
m(row,col) = highValue;
bool notdone = true;
int step = 1;
this->matrix = m;
// STAR == 1 == starred, PRIME == 2 == primed
mask_matrix.resize(matrix.rows(), matrix.columns());
row_mask = new bool[matrix.rows()];
col_mask = new bool[matrix.columns()];
for ( int i = 0 ; i < matrix.rows() ; i++ ) {
row_mask[i] = false;
}
for ( int i = 0 ; i < matrix.columns() ; i++ ) {
col_mask[i] = false;
}
while ( notdone ) {
switch ( step ) {
case 0:
notdone = false;
break;
case 1:
step = step1();
break;
case 2:
step = step2();
break;
case 3:
step = step3();
break;
case 4:
step = step4();
break;
case 5:
step = step5();
break;
}
}
// Store results
for ( int row = 0 ; row < matrix.rows() ; row++ )
for ( int col = 0 ; col < matrix.columns() ; col++ )
if ( mask_matrix(row,col) == STAR )
matrix(row,col) = 0;
else
matrix(row,col) = -1;
#ifdef DEBUG
std::cout << "Munkres output matrix:" << std::endl;
for ( int row = 0 ; row < matrix.rows() ; row++ ) {
for ( int col = 0 ; col < matrix.columns() ; col++ ) {
std::cout.width(1);
std::cout << matrix(row,col) << ",";
}
std::cout << std::endl;
}
std::cout << std::endl;
#endif
m = matrix;
delete [] row_mask;
delete [] col_mask;
}
/*
*
* Linear assignment problem solution
* [modifies matrix in-place.]
* matrix(row,col): row major format assumed.
*
* Assignments are remaining 0 values
* (extra 0 values are replaced with -1)
*
*/
void
Munkres::solve(Matrix<double> &m) {
const size_t rows = m.rows(),
columns = m.columns(),
size = std::max(rows, columns);
#ifdef DEBUG
std::cout << "Munkres input matrix:" << std::endl;
for ( size_t row = 0 ; row < rows ; row++ ) {
for ( size_t col = 0 ; col < columns ; col++ ) {
std::cout.width(8);
std::cout << m(row, col) << ",";
}
std::cout << std::endl;
}
std::cout << std::endl;
#endif
// Copy input matrix
this->matrix = m;
if ( rows != columns ) {
// If the input matrix isn't square, make it square
// and fill the empty values with the largest value present
// in the matrix.
matrix.resize(size, size, matrix.max());
}
// STAR == 1 == starred, PRIME == 2 == primed
mask_matrix.resize(size, size);
row_mask = new bool[size];
col_mask = new bool[size];
for ( size_t i = 0 ; i < size ; i++ ) {
row_mask[i] = false;
}
for ( size_t i = 0 ; i < size ; i++ ) {
col_mask[i] = false;
}
// Prepare the matrix values...
// If there were any infinities, replace them with a value greater
// than the maximum value in the matrix.
replace_infinites(matrix);
minimize_along_direction(matrix, false);
minimize_along_direction(matrix, true);
// Follow the steps
int step = 1;
while ( step ) {
switch ( step ) {
case 1:
step = step1();
// step is always 2
break;
case 2:
step = step2();
// step is always either 0 or 3
break;
case 3:
step = step3();
// step in [3, 4, 5]
break;
case 4:
step = step4();
// step is always 2
break;
case 5:
step = step5();
// step is always 3
break;
}
}
// Store results
for ( size_t row = 0 ; row < size ; row++ ) {
for ( size_t col = 0 ; col < size ; col++ ) {
if ( mask_matrix(row, col) == STAR ) {
matrix(row, col) = 0;
} else {
matrix(row, col) = -1;
}
}
}
#ifdef DEBUG
std::cout << "Munkres output matrix:" << std::endl;
for ( size_t row = 0 ; row < rows ; row++ ) {
for ( size_t col = 0 ; col < columns ; col++ ) {
std::cout.width(1);
std::cout << matrix(row, col) << ",";
}
std::cout << std::endl;
}
std::cout << std::endl;
#endif
// Remove the excess rows or columns that we added to fit the
// input to a square matrix.
matrix.resize(rows, columns);
m = matrix;
delete [] row_mask;
delete [] col_mask;
}
void _HungarianAlgorithm<VAL>::solve(std::map<int,int>& o_result)
{
for(int i=0; i<m_size; i++)
m_mask[i] = 0;
int step = 1;
int nbOps = 0;
while(step > 0)
{
//std::cout << "===== step " << step << " =====" << std::endl;
if(nbOps%5000 == 0 && nbOps != 0)
std::cout << "still alive ! (nbOps = " << nbOps << ")" << std::endl;
switch(step)
{
case 1:
step = step1();
break;
case 2:
step = step2();
break;
case 3:
step = step3();
break;
case 4:
step = step4();
break;
case 5:
step = step5();
break;
default:
step = 0;
}
nbOps++;
// for(int j=0; j<m_height; j++)
// {
// for(int i=0; i<m_width; i++)
// {
// std::cout << m_matrix[j*m_height+i] << "\t";
// }
// std::cout << std::endl;
// }
// for(int j=0; j<m_height; j++)
// {
// for(int i=0; i<m_width; i++)
// {
// std::cout << m_mask[j*m_height+i] << "\t";
// }
// std::cout << std::endl;
// }
// std::cout<<"row : ";
// for(int j=0; j<m_height; j++)
// std::cout<<m_mask_row[j]<<" ";
// std::cout<<std::endl<<"col : ";
// for(int j=0; j<m_width; j++)
// std::cout<<m_mask_col[j]<<" ";
// std::cout<<std::endl;
}
for(int j=0; j<m_height; j++)
for(int i=0; i<m_width; i++)
if(m_mask[j*m_height+i] == 1)
o_result[i] = j;
}
//Find a noncovered zero and prime it
//if there isn't a starred zero in its row then goto step 5
//if there is then cover the current row and uncover the column with the starred zero
//then look for more uncovered zeros
//if there are no uncovered zeros we go to step 6
bool munkres::step4(void)
{
//To find the smallest uncovered value
int smallest = 0;
//iterate through rows
for (int i = 0; i < num_rows; i++)
{
//if the current row isn't covered
if (!row_cov[i])
{
//set smallest = first element in the current row
while (smallest == 0){
smallest = cell_array[i][0].weight;
//if the first element is 0 then increase the row
if (smallest == 0)
{
if (i < num_rows-1)
i++;
else
break;
}
}
//iterate through columns
for (int j = 0; j < num_columns; j++)
{
//if the column and row aren't covered, the current index is zero,
//and there isn't a star in the current row,
//then prime the current index and go to step 5
if (!column_cov[j] && !row_cov[i] && cell_array[i][j].weight == 0 && !row_starred[i])
{
//prime current index
cell_array[i][j].primed = true;
//if a primed zero with no star in the row exists
//goto step 5
if (diag_on)
{
std::cerr << "Step 4: " << i << ", " << j <<std::endl;
diagnostic(6);
}
return step5(i, j);
}
//if the column and row aren't covered, the current index is zero,
//and there is a star in the current row,
//then prime the current index, cover the current row,
//and uncover the column with the starred zero
//also reset indeces to 0 to look for zeros that may have been uncovered
else if (!column_cov[j] && !row_cov[i] && cell_array[i][j].weight == 0)
{
//prime current index
cell_array[i][j].primed = true;
//cover current row
row_cov[i] = true;
//uncover column with starred zero
column_cov[find_star_row(i)] = false;
i = 0;
j = 0;
}
//if the column isn't covered, the current index isn't zero,
//and the current index is smaller than smallest so far,
//then set smallest == current index
else if (!column_cov[j] && cell_array[i][j].weight != 0 && cell_array[i][j].weight < smallest)
{
//set smallest == current index
smallest = cell_array[i][j].weight;
}
}
}
}
if (diag_on)
{
std::cerr << "Step 4" << std::endl;
diagnostic(6);
}
//if we don't go to step 5 then go to step 6
return step6(smallest);
}
/*!
Linear assignment problem solution
[modifies matrix in-place.]
matrix(row,col): row major format assumed.
Assignments are remaining 0 values on 'matrix'
(extra 0 values are replaced with -1)
The correspondence results are stored in the variables
row2colMap and col2rowMap s.t.
row2colMap(r) = c means that col c is assigned to row r
col2rowMap(c) = r means that row r is assigned to column c
@param initMaps if true the row/col maps are init to invalid values,
which help check the mapping by calling CheckMapping()
*/
double Munkres::Solve(const DoubleMatrix& m, UIntVector* row2colMap,
UIntVector* col2rowMap)
{
#ifdef MUNKRES_DEBUG
std::cout << "Munkres input matrix:" << std::endl;
for ( int row = 0 ; row < m.rows() ; row++ )
{
for ( int col = 0 ; col < m.columns() ; col++ ) {
std::cout.width(8);
std::cout << m(row,col) << ",";
}
std::cout << std::endl;
}
std::cout << std::endl;
#endif
bool notdone = true;
int step = 1;
// Copy m, because it need to be modified
matrix = m;
// Z_STAR == 1 == starred, Z_PRIME == 2 == primed
mask_matrix.set_size(matrix.rows(), matrix.columns());
mask_matrix.fill(0);
row_mask = new bool[matrix.rows()];
col_mask = new bool[matrix.columns()];
for ( unsigned i = 0 ; i < matrix.rows() ; i++ ) {
row_mask[i] = false;
}
for ( unsigned i = 0 ; i < matrix.columns() ; i++ ) {
col_mask[i] = false;
}
while ( notdone ) {
switch ( step ) {
case 0:
notdone = false;
break;
case 1:
step = step1();
break;
case 2:
step = step2();
break;
case 3:
step = step3();
break;
case 4:
step = step4();
break;
case 5:
step = step5();
break;
}
}
delete[] row_mask;
delete[] col_mask;
// Store results
/*
for ( unsigned row = 0 ; row < matrix.rows() ; row++ )
for ( unsigned col = 0 ; col < matrix.columns() ; col++ )
if ( mask_matrix(row,col) == Z_STAR )
matrix(row,col) = 0;
else
matrix(row,col) = -1;
#ifdef MUNKRES_DEBUG
std::cout << "Munkres output matrix:" << std::endl;
for ( int row = 0 ; row < matrix.rows() ; row++ ) {
for ( int col = 0 ; col < matrix.columns() ; col++ ) {
std::cout.width(1);
std::cout << matrix(row,col) << ",";
}
std::cout << std::endl;
}
std::cout << std::endl;
#endif
*/
// Store results in the row and col maps s.t.
// row2colMap(r) = c means that col c is assigned to row r
// col2rowMap(c) = r means that row r is assigned to column c
// Init vector to "known" invalid values
if (row2colMap)
{
row2colMap->set_size(matrix.rows());
row2colMap->fill(UINT_MAX);
}
// Init vector to "known" invalid values
if (col2rowMap)
{
col2rowMap->set_size(matrix.cols());
col2rowMap->fill(UINT_MAX);
}
double matchCost = 0;
for (unsigned row = 0 ; row < matrix.rows() ; ++row)
{
for (unsigned col = 0 ; col < matrix.columns() ; ++col)
{
if (mask_matrix(row,col) == Z_STAR)
{
if (row2colMap)
(*row2colMap)[row] = col;
if (col2rowMap)
(*col2rowMap)[col] = row;
matchCost += m[row][col]; // use given 'm' not 'matrix'!
}
}
}
return matchCost;
}
/*
*
* Linear assignment problem solution
* [modifies matrix in-place.]
* matrix(row,col): row major format assumed.
*
* Assignments are remaining 0 values
* (extra 0 values are replaced with -1)
*
*/
void
Munkres::solve(cv::Mat_<int> &m) {
const unsigned int rows = m.rows,
columns = m.cols,
size = std::max<unsigned int>(rows, columns);
if(isDiag) {
std::cout << "Munkres input matrix:" << std::endl;
for ( unsigned int row = 0 ; row < rows ; row++ ) {
for ( unsigned int col = 0 ; col < columns ; col++ ) {
std::cout.width(4);
std::cout << m(row, col) << ",";
}
std::cout << std::endl;
}
std::cout << std::endl;
}
bool notdone = true;
int step = 1;
// Copy input matrix
this->matrix = m;
if ( rows != columns ) {
// If the input matrix isn't square, make it square
// and fill the empty values with the largest value present
// in the matrix.
extendMat(matrix, size, size, maxValue(matrix));
}
// STAR == 1 == starred, PRIME == 2 == primed
// mask_matrix.resize(size, size);
extendMat(mask_matrix, size, size);
row_mask = new bool[size];
col_mask = new bool[size];
for ( unsigned int i = 0 ; i < size ; i++ ) {
row_mask[i] = false;
}
for ( unsigned int i = 0 ; i < size ; i++ ) {
col_mask[i] = false;
}
// Prepare the matrix values...
// If there were any infinities, replace them with a value greater
// than the maximum value in the matrix.
replace_infinites(matrix);
minimize_along_direction(matrix, false);
minimize_along_direction(matrix, true);
// Follow the steps
while ( notdone ) {
switch ( step ) {
case 0:
notdone = false;
// end the step flow
break;
case 1:
step = step1();
// step is always 2
break;
case 2:
step = step2();
// step is always either 0 or 3
break;
case 3:
step = step3();
// step in [3, 4, 5]
break;
case 4:
step = step4();
// step is always 2
break;
case 5:
step = step5();
// step is always 3
break;
}
}
// Store results
for ( unsigned int row = 0 ; row < size ; row++ ) {
for ( unsigned int col = 0 ; col < size ; col++ ) {
if ( mask_matrix(row, col) == STAR ) {
matrix(row, col) = 0;
} else {
matrix(row, col) = -1;
}
}
}
if(isDiag) {
std::cout << "Munkres output matrix:" << std::endl;
for ( unsigned int row = 0 ; row < rows ; row++ ) {
for ( unsigned int col = 0 ; col < columns ; col++ ) {
std::cout.width(2);
std::cout << matrix(row, col) << ",";
}
std::cout << std::endl;
}
std::cout << std::endl;
}
// Remove the excess rows or columns that we added to fit the
// input to a square matrix.
// matrix.resize(rows, columns);
extendMat(matrix, rows, columns);
m = matrix;
delete [] row_mask;
delete [] col_mask;
}
// usage: smp <IP address to connect to>
int main( int argc, char** argv )
{
if ( argc != 2 ) /* argc should be 2 for correct execution */
{
printf( "usage:\n\tsmp <ipaddress>\n\tsmp server\n" );
return EXIT_FAILURE;
}
int bServerMode = strstr( "server", argv[ 1 ] ) != 0;
setup();
unsigned char holder[ BUFFER_SIZE ];
memset( holder, 0x00, BUFFER_SIZE );
if ( !bServerMode )
{
// we are talking to the server at ip address argv[ 1 ]
char input_string[ 256 ];
printf( "Enter a shared secret: " );
readLine( input_string, 256 );
// TESTCODE: strcpy( input_string, "testme" );
secret = binEncode( input_string, strlen( input_string ) );
/*****************************************************/
/*****************************************************/
/* Do Step 1 and send to other side */
/*****************************************************/
/*****************************************************/
int len = step1( holder, BUFFER_SIZE );
int serverfd = connect_to_server( argv[ 1 ] );
if ( serverfd == 1 )
return EXIT_FAILURE;
write_to_server( serverfd, holder, len );
// dumpBuff( holder, len );
/*****************************************************/
/*****************************************************/
/* Get results from other side. */
/* Other side performed Step 2. */
/*****************************************************/
/*****************************************************/
memset( holder, 0x00, BUFFER_SIZE );
len = revc_from_server( serverfd, holder, BUFFER_SIZE );
// dumpBuff( holder, len );
/*****************************************************/
/*****************************************************/
/* Do Step 3 and send to the other side */
/*****************************************************/
/*****************************************************/
step3( holder, BUFFER_SIZE );
write_to_server( serverfd, holder, len );
/*****************************************************/
/*****************************************************/
/* Get bytes from other side and do Step 5 */
/*****************************************************/
/*****************************************************/
memset( holder, 0x00, BUFFER_SIZE );
len = revc_from_server( serverfd, holder, BUFFER_SIZE );
// dumpBuff( holder, len );
step5( holder, len );
disconnect_from_server( serverfd );
}
else // we are in server mode, other side will send us data first
{
int listenfd = listen_server();
/*if ( listenfd == 1 )
return EXIT_FAILURE;
TODO: error checking
*/
char input_string[ 256 ];
printf( "Enter a shared secret: " );
readLine( input_string, 256 );
// TESTCODE: strcpy( input_string, "testme" );
secret = binEncode( input_string, strlen( input_string ) );
int len = revc_from_server( listenfd, holder, BUFFER_SIZE );
// dumpBuff( holder, BUFFER_SIZE);
/*****************************************************/
/*****************************************************/
/* Do Step 2 and send to other side */
/*****************************************************/
/*****************************************************/
len = step2( holder, BUFFER_SIZE );
write_to_server( listenfd, holder, len );
len = revc_from_server( listenfd, holder, BUFFER_SIZE );
// dumpBuff( holder, len );
/*****************************************************/
/*****************************************************/
/* Do Step 4 and send to other side */
/*****************************************************/
/*****************************************************/
len = step4( holder, BUFFER_SIZE );
write_to_server( listenfd, holder, len );
disconnect_from_server( listenfd );
}
if ( match == 1 )
printf( "Secrets match\n" );
else
printf( "Secrets do not match\n");
cleanup();
return EXIT_SUCCESS;
}
