vdiff.cc

Go to the documentation of this file.

/*
 *  Copyright 2007 Martin von Gagern
 *
 *
 *  This file is part of mqn2mps.
 *
 *  mqn2mps 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 3 of the License, or
 *  (at your option) any later version.
 *
 *  mqn2mps 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 */


#include <string>
#include <vector>
#include <set>
#include <algorithm>

#include "triplet.hh"
#include "rational.hh"
#include "field.hh"
#include "vdiff.hh"

/**
 * @file
 * Implementation of class vdiff.
 */

/**
 * Lexicographically compare two containers.
 *
 * As the STL implementation of lexicographical comparison has such an
 * awfully long name, and operates on iterator pairs instead of
 * container objects, the use of this wrapper function makes code
 * somewhat shorter.
 *
 * @param a the first container to compare.
 * @param b the second container to compare.
 * @return whether @e a is lexicographically less than @e b.
 */
template<class A, class B> static inline bool lexcmp(const A& a, const B& b) {
  return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end());
}

/**
 * Compare fields by their components.
 * This helper class can be passed as a template argument to
 * containers class or generic algorithm to define sorting on field
 * pointers.
 */
struct field_cmp {
  /**
   * Compare fields by their components.
   * @param a a pointer to the first field to be compared.
   * @param b a pointer to the second field to be compared.
   * @return whether the values of @e a are lexicographically less
   *         than those of @e b.
   */
  bool operator() (const field* a, const field* b) {
    return lexcmp(a->values, b->values);
  }
};

/**
 * Constructor that calculates difference vectors.
 *
 * Given a set of input vectors (field descriptions), this constructor
 * sorts them, calculates differences between the first and subsequent
 * vectors, and stores these difference vectors internally.
 *
 * @param[in,out] fields a collection of fields, will be sorted.
 */
vdiff::vdiff(std::vector<const field*>& fields) {
  std::sort(fields.begin(), fields.end(), field_cmp());
  rows = fields[0]->values.size();
  cols = fields.size() - 1;
  for (int col = 1; col <= cols; ++col) {
    for (int row = 0; row < rows; ++row) {
      if (fields[0]->values[row] != fields[col]->values[row])
        elements.insert(make_triplet(row, col-1, fields[col]->values[row]
                                     - fields[0]->values[row]));
    }
  }
}

/**
 * Retrieve a difference operator.
 *
 * The difference vector with the given index is constructed on the
 * fly. Assuming input consisted of vectors v[0] thrugh v[n], then for
 * a given argument i this method here will return the vector
 * v[i+1]-v[0]. Obviously the maximum index is two less than the
 * number of input vectors to the constructor.
 *
 * @param col the index of the difference vector to be returned.
 * @return the specified difference vector.
 */
field vdiff::operator[](int col) const {
  field res;
  res.values.resize(rows);
  for (std::set< triplet<rational> >::iterator
         i = elements.begin(), e = elements.end(); i != e; ++i) {
    if (i->col == col) res.values[i->row] = i->val;
  }
  return res;
}

/**
 * Compare sets of vector differences.
 *
 * The comparison is implemented as a lexicographical comparison over
 * matrix element triplets. However, any total order should do.
 *
 * @param d the other set of difference vectors.
 * @return whether this set is less than the other set of difference
 *         vectors.
 */
bool vdiff::operator<(const vdiff& d) const {
  if (cols != d.cols) return cols < d.cols;
  return lexcmp(elements, d.elements);
}

---