validation.cpp

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*                                                                           */
/*                  This file is part of the class library                   */
/*       SoPlex --- the Sequential object-oriented simPlex.                  */
/*                                                                           */
/*    Copyright (C) 1996-2019 Konrad-Zuse-Zentrum                            */
/*                            fuer Informationstechnik Berlin                */
/*                                                                           */
/*  SoPlex is distributed under the terms of the ZIB Academic Licence.       */
/*                                                                           */
/*  You should have received a copy of the ZIB Academic License              */
/*  along with SoPlex; see the file COPYING. If not email to soplex@zib.de.  */
/*                                                                           */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

/**@file  validation.cpp
 * @brief Validation object for soplex solutions
 */

#include "soplex/validation.h"

namespace soplex
{

/// updates the external solution used for validation
bool Validation::updateExternalSolution(char* solution)
{
   validate = true;
   validatesolution = solution;

   if(strncmp(solution, "+infinity", 9) == 0)
      return true;
   else if(strncmp(solution, "-infinity", 9) == 0)
      return true;
   else
   {
      char* tailptr;
      strtod(solution, &tailptr);

      if(*tailptr)
      {
         //conversion failed because the input wasn't a number
         return false;
      }
   }

   return true;
}



/// updates the tolerance used for validation
bool Validation::updateValidationTolerance(char* tolerance)
{
   char* tailptr;
   validatetolerance = strtod(tolerance, &tailptr);

   if(*tailptr)
   {
      //conversion failed because the input wasn't a number
      return false;
   }

   return true;
}



/// validates the soplex solution using the external solution
void Validation::validateSolveReal(SoPlex& soplex)
{
   bool passedValidation = true;
   std::string reason = "";
   Real objViolation = 0.0;
   Real maxBoundViolation = 0.0;
   Real maxRowViolation = 0.0;
   Real maxRedCostViolation = 0.0;
   Real maxDualViolation = 0.0;
   Real sumBoundViolation = 0.0;
   Real sumRowViolation = 0.0;
   Real sumRedCostViolation = 0.0;
   Real sumDualViolation = 0.0;
   Real sol;

   std::ostream& os = soplex.spxout.getStream(SPxOut::INFO1);

   if(strncmp(validatesolution, "+infinity", 9) == 0)
      sol =  soplex.realParam(SoPlex::INFTY);
   else if(strncmp(validatesolution, "-infinity", 9) == 0)
      sol =  -soplex.realParam(SoPlex::INFTY);
   else
   {
      sol = atof(validatesolution);
   }

   objViolation = spxAbs(sol - soplex.objValueReal());

   // skip check in case presolving detected infeasibility/unboundedness
   if(SPxSolver::INForUNBD == soplex.status() &&
         (sol == soplex.realParam(SoPlex::INFTY) || sol == -soplex.realParam(SoPlex::INFTY)))
      objViolation = 0.0;

   if(! EQ(objViolation, 0.0, validatetolerance))
   {
      passedValidation = false;
      reason += "Objective Violation; ";
   }

   if(SPxSolver::OPTIMAL == soplex.status())
   {
      soplex.getBoundViolationReal(maxBoundViolation, sumBoundViolation);
      soplex.getRowViolationReal(maxRowViolation, sumRowViolation);
      soplex.getRedCostViolationReal(maxRedCostViolation, sumRedCostViolation);
      soplex.getDualViolationReal(maxDualViolation, sumDualViolation);

      if(! LE(maxBoundViolation, validatetolerance))
      {
         passedValidation = false;
         reason += "Bound Violation; ";
      }

      if(! LE(maxRowViolation, validatetolerance))
      {
         passedValidation = false;
         reason += "Row Violation; ";
      }

      if(! LE(maxRedCostViolation, validatetolerance))
      {
         passedValidation = false;
         reason += "Reduced Cost Violation; ";
      }

      if(! LE(maxDualViolation, validatetolerance))
      {
         passedValidation = false;
         reason += "Dual Violation; ";
      }
   }

   os << "\n";
   os << "Validation          :";

   if(passedValidation)
      os << " Success\n";
   else
   {
      reason[reason.length() - 2] = ']';
      os << " Fail [" + reason + "\n";
   }

   os << "   Objective        : " << std::scientific << std::setprecision(
         8) << objViolation << std::fixed << "\n";
   os << "   Bound            : " << std::scientific << std::setprecision(
         8) << maxBoundViolation << std::fixed << "\n";
   os << "   Row              : " << std::scientific << std::setprecision(
         8) << maxRowViolation << std::fixed << "\n";
   os << "   Reduced Cost     : " << std::scientific << std::setprecision(
         8) << maxRedCostViolation << std::fixed << "\n";
   os << "   Dual             : " << std::scientific << std::setprecision(
         8) << maxDualViolation << std::fixed << "\n";
}

} /* namespace soplex */