cons_savesdpsol.c

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/*                                                                           */
/* This file is part of SCIPSDP - a solving framework for mixed-integer      */
/* semidefinite programs based on SCIP.                                      */
/*                                                                           */
/* Copyright (C) 2011-2013 Discrete Optimization, TU Darmstadt               */
/*                         EDOM, FAU Erlangen-Nürnberg                       */
/*               2014-2020 Discrete Optimization, TU Darmstadt               */
/*                                                                           */
/*                                                                           */
/* This program is free software; you can redistribute it and/or             */
/* modify it under the terms of the GNU Lesser General Public License        */
/* as published by the Free Software Foundation; either version 3            */
/* of the License, or (at your option) any later version.                    */
/*                                                                           */
/* This program 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 Lesser General Public License for more details.                       */
/*                                                                           */
/* You should have received a copy of the GNU Lesser General Public License  */
/* along with this program; if not, write to the Free Software               */
/* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA.*/
/*                                                                           */
/*                                                                           */
/* Based on SCIP - Solving Constraint Integer Programs                       */
/* Copyright (C) 2002-2020 Zuse Institute Berlin                             */
/* SCIP is distributed under the terms of the SCIP Academic Licence,         */
/* see file COPYING in the SCIP distribution.                                */
/*                                                                           */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

/*#define SCIP_DEBUG*/
/*#define SCIP_MORE_DEBUG *//* shows all cuts added */

#include "cons_savesdpsol.h"
#include "scip/def.h"                        /* for SCIP_Real, _Bool, ... */
#include <string.h>
#include <assert.h>

/* constraint handler properties */
#define CONSHDLR_NAME          "Savesdpsol"
#define CONSHDLR_DESC          "saving the SDP solution at each node of the tree constraint handler"
#define CONSHDLR_ENFOPRIORITY         0 
#define CONSHDLR_CHECKPRIORITY        0 
#define CONSHDLR_EAGERFREQ          100 
#define CONSHDLR_NEEDSCONS         TRUE 
struct SCIP_ConsData
{
   SCIP_Longint          node;               
   SCIP_SOL*             sol;                
   SCIP_Real             maxprimalentry;     
   int                   nblocks;            
   int*                  startXnblocknonz;   
   int**                 startXrow;          
   int**                 startXcol;          
   SCIP_Real**           startXval;          
};

static
SCIP_DECL_CONSDELETE(consDeleteSavesdpsol)
{  /*lint --e{715}*/
   int b;

   assert( scip != NULL );
   assert( conshdlr != NULL );
   assert( cons != NULL );
   assert( consdata != NULL );
   assert( *consdata != NULL );

   SCIPdebugMsg(scip, "Deleting store node data constraint: <%s>.\n", SCIPconsGetName(cons));

   for (b = 0; b < (*consdata)->nblocks; b++)
   {
      SCIPfreeBlockMemoryArray(scip, &((*consdata)->startXval[b]), (*consdata)->startXnblocknonz[b]);
      SCIPfreeBlockMemoryArray(scip, &((*consdata)->startXcol[b]), (*consdata)->startXnblocknonz[b]);
      SCIPfreeBlockMemoryArray(scip, &((*consdata)->startXrow[b]), (*consdata)->startXnblocknonz[b]);
   }
   SCIPfreeBlockMemoryArray(scip, &((*consdata)->startXval), (*consdata)->nblocks);
   SCIPfreeBlockMemoryArray(scip, &((*consdata)->startXcol), (*consdata)->nblocks);
   SCIPfreeBlockMemoryArray(scip, &((*consdata)->startXrow), (*consdata)->nblocks);
   SCIPfreeBlockMemoryArray(scip, &((*consdata)->startXnblocknonz), (*consdata)->nblocks);

   SCIP_CALL( SCIPfreeSol(scip, &((*consdata)->sol)) );
   SCIPfreeBlockMemory(scip, consdata);

   return SCIP_OKAY;
}


static
SCIP_DECL_CONSENFORELAX(consEnforelaxSavesdpsol)
{  /*lint --e{715}*/
   assert( scip != NULL );
   assert( conshdlr != NULL );
   assert( strcmp(SCIPconshdlrGetName(conshdlr), CONSHDLR_NAME) == 0 );
   assert( result != NULL );

   /* do nothing */
   *result = SCIP_FEASIBLE;

   return SCIP_OKAY;
}


static
SCIP_DECL_CONSENFOLP(consEnfolpSavesdpsol)
{  /*lint --e{715}*/
   assert( scip != NULL );
   assert( conshdlr != NULL );
   assert( strcmp(SCIPconshdlrGetName(conshdlr), CONSHDLR_NAME) == 0 );
   assert( result != NULL );

   /* do nothing */
   *result = SCIP_FEASIBLE;

   return SCIP_OKAY;
}


static
SCIP_DECL_CONSENFOPS(consEnfopsSavesdpsol)
{  /*lint --e{715}*/
   assert( scip != NULL );
   assert( conshdlr != NULL );
   assert( strcmp(SCIPconshdlrGetName(conshdlr), CONSHDLR_NAME) == 0 );
   assert( result != NULL );

   /* do nothing */
   *result = SCIP_FEASIBLE;

   return SCIP_OKAY;
}


static
SCIP_DECL_CONSCHECK(consCheckSavesdpsol)
{  /*lint --e{715}*/
   assert( scip != NULL );
   assert( conshdlr != NULL );
   assert( strcmp(SCIPconshdlrGetName(conshdlr), CONSHDLR_NAME) == 0 );
   assert( result != NULL );

   /* do nothing */
   *result = SCIP_FEASIBLE;

   return SCIP_OKAY;
}


static
SCIP_DECL_CONSLOCK(consLockSavesdpsol)
{  /*lint --e{715}*/
   assert( scip != NULL );
   assert( conshdlr != NULL );
   assert( strcmp(SCIPconshdlrGetName(conshdlr), CONSHDLR_NAME) == 0 );

   /* do nothing */
   return SCIP_OKAY;
}


static
SCIP_DECL_CONSHDLRCOPY(conshdlrCopySavesdpsol)
{  /*lint --e{715}*/
   assert( scip != NULL );
   assert( conshdlr != NULL );
   assert( strcmp(SCIPconshdlrGetName(conshdlr), CONSHDLR_NAME) == 0 );
   assert( valid != NULL );

   /* call inclusion method of constraint handler */
   SCIP_CALL( SCIPincludeConshdlrSavesdpsol(scip) );

   *valid = TRUE;

   return SCIP_OKAY;
}


static
SCIP_DECL_CONSCOPY(consCopySavesdpsol)
{  /*lint --e{715}*/
   /* do not do anything: no Savesdpsol constraint should be present in the copy */
   return SCIP_OKAY;
}


SCIP_RETCODE SCIPincludeConshdlrSavesdpsol(
   SCIP*                 scip                
   )
{
   SCIP_CONSHDLR* conshdlr;

   /* include constraint handler */
   conshdlr = NULL;
   SCIP_CALL( SCIPincludeConshdlrBasic(scip, &conshdlr, CONSHDLR_NAME, CONSHDLR_DESC,
         CONSHDLR_ENFOPRIORITY, CONSHDLR_CHECKPRIORITY, CONSHDLR_EAGERFREQ, CONSHDLR_NEEDSCONS,
         consEnfolpSavesdpsol, consEnfopsSavesdpsol, consCheckSavesdpsol, consLockSavesdpsol,
         NULL) );
   assert( conshdlr != NULL );

   /* set additional callbacks */
   SCIP_CALL( SCIPsetConshdlrDelete(scip, conshdlr, consDeleteSavesdpsol) );
   SCIP_CALL( SCIPsetConshdlrCopy(scip, conshdlr, conshdlrCopySavesdpsol, consCopySavesdpsol) );
   SCIP_CALL( SCIPsetConshdlrEnforelax(scip, conshdlr, consEnforelaxSavesdpsol) );

   return SCIP_OKAY;
}


/*
 * External functions
 */

SCIP_RETCODE createConsSavesdpsol(
   SCIP*                 scip,               
   SCIP_CONS**           cons,               
   const char*           name,               
   SCIP_Longint          node,               
   SCIP_SOL*             sol,                
   SCIP_Real             maxprimalentry,     
   int                   nblocks,            
   int*                  startXnblocknonz,   
   int**                 startXrow,          
   int**                 startXcol,          
   SCIP_Real**           startXval           
   )
{
   SCIP_CONSDATA* consdata = NULL;
   SCIP_CONSHDLR* conshdlr;
   int b;

   assert( scip != NULL );
   assert( name != NULL );
   assert( sol != NULL );
   assert( nblocks >= 0 );
   assert( nblocks == 0 || startXnblocknonz != NULL );
   assert( nblocks == 0 || startXrow != NULL );
   assert( nblocks == 0 || startXcol != NULL );
   assert( nblocks == 0 || startXval != NULL );

   SCIPdebugMsg(scip, "Creating Savesdpsol constraint <%s>.\n", name);

   /* find the node data constraint handler */
   conshdlr = SCIPfindConshdlr(scip, "Savesdpsol");
   if ( conshdlr == NULL )
   {
      SCIPerrorMessage("Savesdpsol constraint handler not found\n");
      return SCIP_PLUGINNOTFOUND;
   }

   /* create constraint data */
   SCIP_CALL( SCIPallocBlockMemory(scip, &consdata) );

   consdata->node = node;
   SCIP_CALL( SCIPcreateSolCopy(scip, &(consdata->sol), sol) );
   SCIP_CALL( SCIPunlinkSol(scip, consdata->sol) );
   consdata->maxprimalentry = maxprimalentry;

   /* allocate memory for primal solution and copy startXnblocknonz*/
   if ( startXnblocknonz != NULL )
   {
      SCIP_CALL( SCIPduplicateBlockMemoryArray(scip, &consdata->startXnblocknonz, startXnblocknonz, nblocks) );
   }
   else
      consdata->startXnblocknonz = NULL;

   SCIP_CALL( SCIPallocBlockMemoryArray(scip, &consdata->startXrow, nblocks) );
   SCIP_CALL( SCIPallocBlockMemoryArray(scip, &consdata->startXcol, nblocks) );
   SCIP_CALL( SCIPallocBlockMemoryArray(scip, &consdata->startXval, nblocks) );

   for (b = 0; b < nblocks; b++)
   {
      assert( startXnblocknonz != NULL );
      SCIP_CALL( SCIPduplicateBlockMemoryArray(scip, &consdata->startXrow[b], startXrow[b], startXnblocknonz[b]) );
      SCIP_CALL( SCIPduplicateBlockMemoryArray(scip, &consdata->startXcol[b], startXcol[b], startXnblocknonz[b]) );
      SCIP_CALL( SCIPduplicateBlockMemoryArray(scip, &consdata->startXval[b], startXval[b], startXnblocknonz[b]) );
   }

   consdata->nblocks = nblocks;

   /* create constraint */
   SCIP_CALL( SCIPcreateCons(scip, cons, name, conshdlr, consdata, FALSE, FALSE, FALSE, FALSE, FALSE,
         TRUE, FALSE, TRUE, FALSE, TRUE));

   return SCIP_OKAY;
}

SCIP_Longint SCIPconsSavesdpsolGetNodeIndex(
   SCIP*                 scip,               
   SCIP_CONS*            cons                
   )
{
   SCIP_CONSDATA* consdata;

   assert ( scip != NULL );
   assert ( cons != NULL );

   consdata = SCIPconsGetData(cons);

   assert ( consdata != NULL );

   return consdata->node;
}

SCIP_SOL* SCIPconsSavesdpsolGetDualVector(
   SCIP*                 scip,               
   SCIP_CONS*            cons                
   )
{
   SCIP_CONSDATA* consdata;

   assert ( scip != NULL );
   assert ( cons != NULL );

   consdata = SCIPconsGetData(cons);

   assert ( consdata != NULL );

   return consdata->sol;
}

SCIP_Real SCIPconsSavesdpsolGetMaxPrimalEntry(
   SCIP*                 scip,               
   SCIP_CONS*            cons                
   )
{
   SCIP_CONSDATA* consdata;

   assert ( scip != NULL );
   assert ( cons != NULL );

   consdata = SCIPconsGetData(cons);

   assert ( consdata != NULL );

   return consdata->maxprimalentry;
}

SCIP_RETCODE SCIPconsSavesdpsolGetPrimalMatrixNonzeros(
   SCIP*                 scip,               
   SCIP_CONS*            cons,               
   int                   nblocks,            
   int*                  startXnblocknonz    
   )
{
   SCIP_CONSDATA* consdata;
   int b;

   assert ( scip != NULL );
   assert ( cons != NULL );

   consdata = SCIPconsGetData(cons);

   assert ( consdata != NULL );

   if ( nblocks != consdata->nblocks )
   {
      SCIPerrorMessage("SCIPconsSavesdpsolGetPrimalMatrix expected nblocks = %d but got %d\n", consdata->nblocks, nblocks);
      return SCIP_ERROR;
   }

   for (b = 0; b < nblocks; b++)
      startXnblocknonz[b] = consdata->startXnblocknonz[b];

   return SCIP_OKAY;
}

SCIP_RETCODE SCIPconsSavesdpsolGetPrimalMatrix(
   SCIP*                 scip,               
   SCIP_CONS*            cons,               
   int                   nblocks,            
   int*                  startXnblocknonz,   
   int**                 startXrow,          
   int**                 startXcol,          
   SCIP_Real**           startXval           
   )
{
   SCIP_CONSDATA* consdata;
   int b;
   int i;
   SCIP_Bool msgthrown = FALSE;

   assert ( scip != NULL );
   assert ( cons != NULL );

   consdata = SCIPconsGetData(cons);

   assert ( consdata != NULL );

   if ( nblocks != consdata->nblocks )
   {
      SCIPerrorMessage("SCIPconsSavesdpsolGetPrimalMatrix expected nblocks = %d but got %d\n", consdata->nblocks, nblocks);
      return SCIP_ERROR;
   }

   for (b = 0; b < nblocks; b++)
   {
      if ( startXnblocknonz[b] < consdata->startXnblocknonz[b] )
      {
         if ( ! msgthrown )
         {
            SCIPdebugMsg(scip, "Unsufficient arraylength %d for block %d in SCIPconsSavesdpsolGetPrimalMatrix, need at least %d!\n",
               startXnblocknonz[b], b, consdata->startXnblocknonz[b]);
            msgthrown = TRUE;
         }
         startXnblocknonz[b] = consdata->startXnblocknonz[b];
      }
      else
      {
         startXnblocknonz[b] = consdata->startXnblocknonz[b];
         for (i = 0; i < consdata->startXnblocknonz[b]; i++)
         {
            startXrow[b][i] = consdata->startXrow[b][i];
            startXcol[b][i] = consdata->startXcol[b][i];
            startXval[b][i] = consdata->startXval[b][i];
         }
      }
   }

   return SCIP_OKAY;
}