coin_helpers.cc

Go to the documentation of this file.

// Copyright (C) 2000, International Business Machines
// Corporation and others.  All Rights Reserved.
// This code is licensed under the terms of the Eclipse Public License (EPL).
 
#include "coin_helpers.h"
 
#include "CoinPackedMatrix.hpp"
#include "CoinFloatEqual.hpp"
 
/// taken directly from OsiSolverInterface.cpp on 2/17/14 from
/// https://projects.coin-or.org/Osi/browser/trunk. Thanks to John Forrest for
/// his assistance! Some small changes have been made to the original file.
 
namespace cyclus {
 
// Check two agents against each other.  Return nonzero if different.
// Ignore names if that set.
// May modify both agents by cleaning up
 
int differentAgent(OsiSolverInterface& lhs, OsiSolverInterface& rhs,
                   bool /*ignoreNames*/) {
  // set reasonable defaults
  bool takeHint;
  OsiHintStrength strength;
  // Switch off printing if asked to
  bool gotHint = (lhs.getHintParam(OsiDoReducePrint, takeHint, strength));
  assert(gotHint);
  bool printStuff = true;
  // if (strength!=OsiHintIgnore&&takeHint) // always printStuff
  //   printStuff=false;
  int returnCode = 0;
  int numberRows = lhs.getNumRows();
  int numberColumns = lhs.getNumCols();
  int numberIntegers = lhs.getNumIntegers();
  if (numberRows != rhs.getNumRows() || numberColumns != rhs.getNumCols()) {
    if (printStuff)
      printf(
          "** Mismatch on size, this has %d rows, %d columns - rhs has %d "
          "rows, %d columns\n",
          numberRows, numberColumns, rhs.getNumRows(), rhs.getNumCols());
    return 1000;
  }
  if (numberIntegers != rhs.getNumIntegers()) {
    if (printStuff)
      printf("** Mismatch on number of integers, this has %d - rhs has %d\n",
             numberIntegers, rhs.getNumIntegers());
    return 1001;
  }
  int numberErrors1 = 0;
  int numberErrors2 = 0;
  for (int i = 0; i < numberColumns; i++) {
    if (lhs.isInteger(i)) {
      if (!rhs.isInteger(i)) numberErrors1++;
    } else {
      if (rhs.isInteger(i)) numberErrors2++;
    }
  }
  if (numberErrors1 || numberErrors2) {
    if (printStuff)
      printf(
          "** Mismatch on integers, %d (this int, rhs not), %d (this not rhs "
          "int)\n",
          numberErrors1, numberErrors2);
    return 1002;
  }
  // Arrays
  const double* rowLower = lhs.getRowLower();
  const double* rowUpper = lhs.getRowUpper();
  const double* columnLower = lhs.getColLower();
  const double* columnUpper = lhs.getColUpper();
  const double* objective = lhs.getObjCoefficients();
  const double* rowLower2 = rhs.getRowLower();
  const double* rowUpper2 = rhs.getRowUpper();
  const double* columnLower2 = rhs.getColLower();
  const double* columnUpper2 = rhs.getColUpper();
  const double* objective2 = rhs.getObjCoefficients();
  const CoinPackedMatrix* matrix = lhs.getMatrixByCol();
  const CoinPackedMatrix* matrix2 = rhs.getMatrixByCol();
  CoinRelFltEq tolerance;
  int numberDifferentL = 0;
  int numberDifferentU = 0;
  for (int i = 0; i < numberRows; i++) {
    if (!tolerance(rowLower[i], rowLower2[i])) numberDifferentL++;
    if (!tolerance(rowUpper[i], rowUpper2[i])) numberDifferentU++;
  }
  int n = numberDifferentL + numberDifferentU;
  returnCode += n;
  if (n && printStuff)
    printf("Row differences , %d lower, %d upper\n", numberDifferentL,
           numberDifferentU);
  numberDifferentL = 0;
  numberDifferentU = 0;
  int numberDifferentO = 0;
  for (int i = 0; i < numberColumns; i++) {
    if (!tolerance(columnLower[i], columnLower2[i])) numberDifferentL++;
    if (!tolerance(columnUpper[i], columnUpper2[i])) numberDifferentU++;
    if (!tolerance(objective[i], objective2[i])) numberDifferentO++;
  }
  n = numberDifferentL + numberDifferentU + numberDifferentO;
  returnCode += n;
  if (n && printStuff)
    printf("Column differences , %d lower, %d upper, %d objective\n",
           numberDifferentL, numberDifferentU, numberDifferentO);
  if (matrix->getNumElements() == rhs.getNumElements()) {
    if (!matrix->isEquivalent(*matrix2, tolerance)) {
      returnCode += 100;
      if (printStuff) printf("Two matrices are not same\n");
    }
  } else {
    returnCode += 200;
    if (printStuff)
      printf("Two matrices are not same - %d elements and %d elements\n",
             matrix->getNumElements(), matrix2->getNumElements());
  }
  return returnCode;
}
 
}  // namespace cyclus