/* $Id: ClpPredictorCorrector.cpp 1458 2009-11-05 12:34:07Z forrest $ */
// Copyright (C) 2003, International Business Machines
// Corporation and others.  All Rights Reserved.

/* 
   Implements crude primal dual predictor corrector algorithm

 */
//#define SOME_DEBUG

#include "CoinPragma.hpp"
#include <math.h>

#include "CoinHelperFunctions.hpp"
#include "ClpPredictorCorrector.hpp"
#include "CoinPackedMatrix.hpp"
#include "ClpMessage.hpp"
#include "ClpCholeskyBase.hpp"
#include "ClpHelperFunctions.hpp"
#include "ClpQuadraticObjective.hpp"
#include <cfloat>
#include <cassert>
#include <string>
#include <cstdio>
#include <iostream>
#if 0
static int yyyyyy=0;
void ClpPredictorCorrector::saveSolution(std::string fileName)
{
  FILE * fp=fopen(fileName.c_str(),"wb");
  if (fp) {
    int numberRows=numberRows_;
    int numberColumns=numberColumns_;
    fwrite(&numberRows,sizeof(int),1,fp);
    fwrite(&numberColumns,sizeof(int),1,fp);
    CoinWorkDouble dsave[20];
    memset(dsave,0,sizeof(dsave));
    fwrite(dsave,sizeof(CoinWorkDouble),20,fp);
    int msave[20];
    memset(msave,0,sizeof(msave));
    msave[0]=numberIterations_;
    fwrite(msave,sizeof(int),20,fp);
    fwrite(dual_,sizeof(CoinWorkDouble),numberRows,fp);
    fwrite(errorRegion_,sizeof(CoinWorkDouble),numberRows,fp);
    fwrite(rhsFixRegion_,sizeof(CoinWorkDouble),numberRows,fp);
    fwrite(solution_,sizeof(CoinWorkDouble),numberColumns,fp);
    fwrite(solution_+numberColumns,sizeof(CoinWorkDouble),numberRows,fp);
    fwrite(diagonal_,sizeof(CoinWorkDouble),numberColumns,fp);
    fwrite(diagonal_+numberColumns,sizeof(CoinWorkDouble),numberRows,fp);
    fwrite(wVec_,sizeof(CoinWorkDouble),numberColumns,fp);
    fwrite(wVec_+numberColumns,sizeof(CoinWorkDouble),numberRows,fp);
    fwrite(zVec_,sizeof(CoinWorkDouble),numberColumns,fp);
    fwrite(zVec_+numberColumns,sizeof(CoinWorkDouble),numberRows,fp);
    fwrite(upperSlack_,sizeof(CoinWorkDouble),numberColumns,fp);
    fwrite(upperSlack_+numberColumns,sizeof(CoinWorkDouble),numberRows,fp);
    fwrite(lowerSlack_,sizeof(CoinWorkDouble),numberColumns,fp);
    fwrite(lowerSlack_+numberColumns,sizeof(CoinWorkDouble),numberRows,fp);
    fclose(fp);
  } else {
    std::cout<<"Unable to open file "<<fileName<<std::endl;
  }
}
#endif
// Could change on CLP_LONG_CHOLESKY or COIN_LONG_WORK?
static CoinWorkDouble eScale=1.0e27;
static CoinWorkDouble eBaseCaution=1.0e-12;
static CoinWorkDouble eBase=1.0e-12;
static CoinWorkDouble eRatio=1.0e40;
static CoinWorkDouble eRatioCaution=1.0e25;
static CoinWorkDouble eDiagonal=1.0e25;
static CoinWorkDouble eDiagonalCaution=1.0e18;
static CoinWorkDouble eExtra=1.0e-12;

// main function

int ClpPredictorCorrector::solve ( )
{
  problemStatus_=-1;
  algorithm_=1;
  //create all regions
  if (!createWorkingData()) {
    problemStatus_=4;
    return 2;
  }
#if COIN_LONG_WORK 
  // reallocate some regions
  double * dualSave = dual_;
  dual_ = reinterpret_cast<double *>(new CoinWorkDouble[numberRows_]);
  double * reducedCostSave = reducedCost_;
  reducedCost_ = reinterpret_cast<double *>(new CoinWorkDouble[numberColumns_]);
#endif  
  //diagonalPerturbation_=1.0e-25;
  ClpMatrixBase * saveMatrix = NULL;
  // If quadratic then make copy so we can actually scale or normalize
#ifndef NO_RTTI
  ClpQuadraticObjective * quadraticObj = (dynamic_cast< ClpQuadraticObjective*>(objective_));
#else
  ClpQuadraticObjective * quadraticObj = NULL;
  if (objective_->type()==2)
    quadraticObj = (static_cast< ClpQuadraticObjective*>(objective_));
#endif
  /* If modeSwitch is :
     0 - normal
     1 - bit switch off centering
     2 - bit always do type 2
     4 - accept corrector nearly always
  */
  int modeSwitch=0;
  //if (quadraticObj)
    //modeSwitch |= 1; // switch off centring for now
  //if (quadraticObj)
  //modeSwitch |=4;
  ClpObjective * saveObjective = NULL;
  if (quadraticObj) {
    // check KKT is on
    if (!cholesky_->kkt()) {
      //No!
      handler_->message(CLP_BARRIER_KKT,messages_)
	<<CoinMessageEol;
      return -1;
    }
    saveObjective=objective_;
    // We are going to make matrix full rather half
    objective_ = new ClpQuadraticObjective(*quadraticObj,1);
  }
  bool allowIncreasingGap = (modeSwitch&4)!=0;
  // If scaled then really scale matrix
  if (scalingFlag_>0&&rowScale_) {
    saveMatrix = matrix_;
    matrix_ = matrix_->scaledColumnCopy(this);
  }
  //initializeFeasible(); - this just set fixed flag
  smallestInfeasibility_=COIN_DBL_MAX;
  int i;
  for (i=0;i<LENGTH_HISTORY;i++) 
    historyInfeasibility_[i]=COIN_DBL_MAX;

  //bool firstTime=true;
  //firstFactorization(true);
  int returnCode = cholesky_->order(this);
  if (returnCode||cholesky_->symbolic()) {
    printf("Error return from symbolic - probably not enough memory\n");
    problemStatus_=4;
    //delete all temporary regions
    deleteWorkingData();
    if (saveMatrix) {
      // restore normal copy
      delete matrix_;
      matrix_ = saveMatrix;
    }
    // Restore quadratic objective if necessary
    if (saveObjective) {
      delete objective_;
      objective_=saveObjective;
    }
    return -1;
  }
  mu_=1.0e10;
  diagonalScaleFactor_=1.0;
  //set iterations
  numberIterations_=-1;
  int numberTotal = numberRows_+numberColumns_;
  //initialize solution here
  if(createSolution()<0) {
    printf("Not enough memory\n");
    problemStatus_=4;
    //delete all temporary regions
    deleteWorkingData();
    if (saveMatrix) {
      // restore normal copy
      delete matrix_;
      matrix_ = saveMatrix;
    }
    return -1;
  }
  CoinWorkDouble * dualArray = reinterpret_cast<CoinWorkDouble *>(dual_);
  // Could try centering steps without any original step i.e. just center
  //firstFactorization(false);
  CoinZeroN(dualArray,numberRows_);
  multiplyAdd(solution_+numberColumns_,numberRows_,-1.0,errorRegion_,0.0);
  matrix_->times(1.0,solution_,errorRegion_);
  maximumRHSError_=maximumAbsElement(errorRegion_,numberRows_);
  maximumBoundInfeasibility_=maximumRHSError_;
  //CoinWorkDouble maximumDualError_=COIN_DBL_MAX;
  //initialize
  actualDualStep_=0.0;
  actualPrimalStep_=0.0;
  gonePrimalFeasible_=false;
  goneDualFeasible_=false;
  //bool hadGoodSolution=false;
  diagonalNorm_=solutionNorm_;
  mu_=solutionNorm_;
  int numberFixed=updateSolution(-COIN_DBL_MAX);
  int numberFixedTotal=numberFixed;
  //int numberRows_DroppedBefore=0;
  //CoinWorkDouble extra=eExtra;
  //CoinWorkDouble maximumPerturbation=COIN_DBL_MAX;
  //constants for infeas interior point
  const CoinWorkDouble beta2 = 0.99995;
  const CoinWorkDouble tau   = 0.00002;
  CoinWorkDouble lastComplementarityGap=COIN_DBL_MAX*1.0e-20;
  CoinWorkDouble lastStep=1.0;
  // use to see if to take affine
  CoinWorkDouble checkGap = COIN_DBL_MAX;
  int lastGoodIteration=0;
  CoinWorkDouble bestObjectiveGap=COIN_DBL_MAX;
  CoinWorkDouble bestObjective=COIN_DBL_MAX;
  int bestKilled=-1;
  int saveIteration=-1;
  int saveIteration2=-1;
  bool sloppyOptimal=false;
  CoinWorkDouble * savePi=NULL;
  CoinWorkDouble * savePrimal=NULL;
  CoinWorkDouble * savePi2=NULL;
  CoinWorkDouble * savePrimal2=NULL;
  // Extra regions for centering
  CoinWorkDouble * saveX = new CoinWorkDouble[numberTotal];
  CoinWorkDouble * saveY = new CoinWorkDouble[numberRows_];
  CoinWorkDouble * saveZ = new CoinWorkDouble[numberTotal];
  CoinWorkDouble * saveW = new CoinWorkDouble[numberTotal];
  CoinWorkDouble * saveSL = new CoinWorkDouble[numberTotal];
  CoinWorkDouble * saveSU = new CoinWorkDouble[numberTotal];
  // Save smallest mu used in primal dual moves
  CoinWorkDouble smallestPrimalDualMu=COIN_DBL_MAX;
  CoinWorkDouble objScale = optimizationDirection_/
    (rhsScale_*objectiveScale_);
  while (problemStatus_<0) {
    //#define FULL_DEBUG
#ifdef FULL_DEBUG
    {
      int i;
      printf("row    pi          artvec       rhsfx\n");
      for (i=0;i<numberRows_;i++) {
	printf("%d %g %g %g\n",i,dual_[i],errorRegion_[i],rhsFixRegion_[i]);
      }
      printf(" col  dsol  ddiag  dwvec  dzvec dbdslu dbdsll\n");
      for (i=0;i<numberColumns_+numberRows_;i++) {
	printf(" %d %g %g %g %g %g %g\n",i,solution_[i],diagonal_[i],wVec_[i],
	       zVec_[i],upperSlack_[i],lowerSlack_[i]);
      }
    }
#endif
    complementarityGap_=complementarityGap(numberComplementarityPairs_,
					   numberComplementarityItems_,0);
    handler_->message(CLP_BARRIER_ITERATION,messages_)
      <<numberIterations_
      <<static_cast<double>(primalObjective_*objScale- dblParam_[ClpObjOffset])
      << static_cast<double>(dualObjective_*objScale- dblParam_[ClpObjOffset])
      <<static_cast<double>(complementarityGap_)
      <<numberFixedTotal
      <<cholesky_->rank()
      <<CoinMessageEol;
#if 0
    if (numberIterations_==-1) {
      saveSolution("xxx.sav");
      if (yyyyyy)
        exit(99);
    }
#endif
    // move up history
    for (i=1;i<LENGTH_HISTORY;i++) 
      historyInfeasibility_[i-1]=historyInfeasibility_[i];
    historyInfeasibility_[LENGTH_HISTORY-1]=complementarityGap_;
    // switch off saved if changes
    //if (saveIteration+10<numberIterations_&&
    //complementarityGap_*2.0<historyInfeasibility_[0])
    //saveIteration=-1;
    lastStep = CoinMin(actualPrimalStep_,actualDualStep_);
    CoinWorkDouble goodGapChange;
    //#define KEEP_GOING_IF_FIXED 5
#ifndef KEEP_GOING_IF_FIXED 
#define KEEP_GOING_IF_FIXED 10000
#endif
    if (!sloppyOptimal) {
      goodGapChange=0.93;
    } else {
      goodGapChange=0.7;
      if (numberFixed>KEEP_GOING_IF_FIXED)
	goodGapChange=0.99; // make more likely to carry on
    } 
    CoinWorkDouble gapO;
    CoinWorkDouble lastGood=bestObjectiveGap;
    if (gonePrimalFeasible_&&goneDualFeasible_) {
      CoinWorkDouble largestObjective;
      if (CoinAbs(primalObjective_)>CoinAbs(dualObjective_)) {
        largestObjective = CoinAbs(primalObjective_);
      } else {
        largestObjective = CoinAbs(dualObjective_);
      } 
      if (largestObjective<1.0) {
        largestObjective=1.0;
      } 
      gapO=CoinAbs(primalObjective_-dualObjective_)/largestObjective;
      handler_->message(CLP_BARRIER_OBJECTIVE_GAP,messages_)
	<<static_cast<double>(gapO)
	<<CoinMessageEol;
      //start saving best
      bool saveIt=false;
      if (gapO<bestObjectiveGap) { 
        bestObjectiveGap=gapO;
#ifndef SAVE_ON_OBJ
	saveIt=true;
#endif
      }
      if (primalObjective_<bestObjective) {
        bestObjective=primalObjective_;
#ifdef SAVE_ON_OBJ
	saveIt=true;
#endif
      }
      if (numberFixedTotal>bestKilled) {
	bestKilled=numberFixedTotal;
#if KEEP_GOING_IF_FIXED<10
	saveIt=true;
#endif
      }
      if (saveIt) {
#if KEEP_GOING_IF_FIXED<10
	printf("saving\n");
#endif
        saveIteration=numberIterations_;
        if (!savePi) {
          savePi=new CoinWorkDouble[numberRows_];
          savePrimal = new CoinWorkDouble [numberTotal];
        } 
        CoinMemcpyN(dualArray,numberRows_,savePi);
	CoinMemcpyN(solution_,numberTotal,savePrimal);
      } else if(gapO>2.0*bestObjectiveGap) {
        //maybe be more sophisticated e.g. re-initialize having
        //fixed variables and dropped rows
        //std::cout <<" gap increasing "<<std::endl;
      } 
      //std::cout <<"could stop"<<std::endl;
      //gapO=0.0;
      if (CoinAbs(primalObjective_-dualObjective_)<dualTolerance()) {
        gapO=0.0;
      } 
    } else {
      gapO=COIN_DBL_MAX;
      if (saveIteration>=0) {
	handler_->message(CLP_BARRIER_GONE_INFEASIBLE,messages_)
	  <<CoinMessageEol;
	CoinWorkDouble scaledRHSError=maximumRHSError_/(solutionNorm_+10.0);
	// save alternate
	if (numberFixedTotal>bestKilled&&
	    maximumBoundInfeasibility_<1.0e-6&&
	    scaledRHSError<1.0e-2) {
	  bestKilled=numberFixedTotal;
#if KEEP_GOING_IF_FIXED<10
	  printf("saving alternate\n");
#endif
	  saveIteration2=numberIterations_;
	  if (!savePi2) {
	    savePi2=new CoinWorkDouble[numberRows_];
	    savePrimal2 = new CoinWorkDouble [numberTotal];
	  } 
	  CoinMemcpyN(dualArray,numberRows_,savePi2);
	  CoinMemcpyN(solution_,numberTotal,savePrimal2);
	}
	if (sloppyOptimal) {
	  // vaguely optimal
	  if (maximumBoundInfeasibility_>1.0e-2||
	      scaledRHSError>1.0e-2||
	      maximumDualError_>objectiveNorm_*1.0e-2) {
	    handler_->message(CLP_BARRIER_EXIT2,messages_)
	      <<saveIteration
	      <<CoinMessageEol;
	    problemStatus_=0; // benefit of doubt
	    break;
	  }
	} else {
	  // not close to optimal but check if getting bad
	  CoinWorkDouble scaledRHSError=maximumRHSError_/(solutionNorm_+10.0);
	  if ((maximumBoundInfeasibility_>1.0e-1||
	      scaledRHSError>1.0e-1||
	       maximumDualError_>objectiveNorm_*1.0e-1)
	      &&(numberIterations_>50
		 &&complementarityGap_>0.9*historyInfeasibility_[0])) {
	    handler_->message(CLP_BARRIER_EXIT2,messages_)
	      <<saveIteration
	      <<CoinMessageEol;
	    break;
	  }
	  if (complementarityGap_>0.95*checkGap&&bestObjectiveGap<1.0e-3&&
	      (numberIterations_>saveIteration+5||numberIterations_>100)) {
	    handler_->message(CLP_BARRIER_EXIT2,messages_)
	      <<saveIteration
	      <<CoinMessageEol;
	    break;
	  }
	}
      } 
      if (complementarityGap_>0.5*checkGap&&primalObjective_>
	  bestObjective+1.0e-9&&
	  (numberIterations_>saveIteration+5||numberIterations_>100)) {
	handler_->message(CLP_BARRIER_EXIT2,messages_)
	  <<saveIteration
	  <<CoinMessageEol;
	break;
      }
    } 
    if ((gapO<1.0e-6||(gapO<1.0e-4&&complementarityGap_<0.1))&&!sloppyOptimal) {
      sloppyOptimal=true;
      handler_->message(CLP_BARRIER_CLOSE_TO_OPTIMAL,messages_)
	<<numberIterations_<<static_cast<double>(complementarityGap_)
	<<CoinMessageEol;
    } 
    int numberBack = quadraticObj ? 10 : 5;
    //tryJustPredictor=true;
    //printf("trying just predictor\n");
    //}
    if (complementarityGap_>=1.05*lastComplementarityGap) {
      handler_->message(CLP_BARRIER_COMPLEMENTARITY,messages_)
	<<static_cast<double>(complementarityGap_)<<"increasing"
	<<CoinMessageEol;
      if (saveIteration>=0&&sloppyOptimal) {
	handler_->message(CLP_BARRIER_EXIT2,messages_)
	  <<saveIteration
	  <<CoinMessageEol;
        break;
      } else if (numberIterations_-lastGoodIteration>=numberBack&&
		 complementarityGap_<1.0e-6) {
	break; // not doing very well - give up
      } 
    } else if (complementarityGap_<goodGapChange*lastComplementarityGap) {
      lastGoodIteration=numberIterations_;
      lastComplementarityGap=complementarityGap_;
    } else if (numberIterations_-lastGoodIteration>=numberBack&&
	       complementarityGap_<1.0e-3) {
      handler_->message(CLP_BARRIER_COMPLEMENTARITY,messages_)
	<<static_cast<double>(complementarityGap_)<<"not decreasing"
	<<CoinMessageEol;
      if (gapO>0.75*lastGood&&numberFixed<KEEP_GOING_IF_FIXED) {
        break;
      } 
    } else if (numberIterations_-lastGoodIteration>=2&&
	       complementarityGap_<1.0e-6) {
      handler_->message(CLP_BARRIER_COMPLEMENTARITY,messages_)
	<<static_cast<double>(complementarityGap_)<<"not decreasing"
	<<CoinMessageEol;
      break;
    } 
    if (numberIterations_>maximumBarrierIterations_||hitMaximumIterations()) {
      handler_->message(CLP_BARRIER_STOPPING,messages_)
	<<CoinMessageEol;
      problemStatus_=3;
      onStopped(); // set secondary status
      break;
    } 
    if (gapO<targetGap_) {
      problemStatus_=0;
      handler_->message(CLP_BARRIER_EXIT,messages_)
	<<" "
	<<CoinMessageEol;
        break;//finished
    } 
    if (complementarityGap_<1.0e-12) {
      problemStatus_=0;
      handler_->message(CLP_BARRIER_EXIT,messages_)
        <<"- small complementarity gap"
	<<CoinMessageEol;
        break;//finished
    } 
    if (complementarityGap_<1.0e-10&&gapO<1.0e-10) {
      problemStatus_=0;
      handler_->message(CLP_BARRIER_EXIT,messages_)
        <<"- objective gap and complementarity gap both small"
	<<CoinMessageEol;
        break;//finished
    } 
    if (gapO<1.0e-9) {
      CoinWorkDouble value=gapO*complementarityGap_;
      value*=actualPrimalStep_;
      value*=actualDualStep_;
      //std::cout<<value<<std::endl;
      if (value<1.0e-17&&numberIterations_>lastGoodIteration) {
	problemStatus_=0;
	handler_->message(CLP_BARRIER_EXIT,messages_)
	  <<"- objective gap and complementarity gap both smallish and small steps"
	  <<CoinMessageEol;
        break;//finished
      } 
    } 
    CoinWorkDouble nextGap=COIN_DBL_MAX;
    int nextNumber=0;
    int nextNumberItems=0;
    worstDirectionAccuracy_=0.0;
    int newDropped=0;
    //Predictor step
    //prepare for cholesky.  Set up scaled diagonal in deltaX
    //  ** for efficiency may be better if scale factor known before
    CoinWorkDouble norm2=0.0;
    CoinWorkDouble maximumValue;
    getNorms(diagonal_,numberTotal,maximumValue,norm2);
    diagonalNorm_ = CoinSqrt(norm2/numberComplementarityPairs_);
    diagonalScaleFactor_=1.0;
    CoinWorkDouble maximumAllowable=eScale;
    //scale so largest is less than allowable ? could do better
    CoinWorkDouble factor=0.5;
    while (maximumValue>maximumAllowable) {
      diagonalScaleFactor_*=factor;
      maximumValue*=factor;
    } /* endwhile */
    if (diagonalScaleFactor_!=1.0) {
      handler_->message(CLP_BARRIER_SCALING,messages_)
	<<"diagonal"<<static_cast<double>(diagonalScaleFactor_)
	<<CoinMessageEol;
      diagonalNorm_*=diagonalScaleFactor_;
    } 
    multiplyAdd(NULL,numberTotal,0.0,diagonal_,
		diagonalScaleFactor_);
    int * rowsDroppedThisTime = new int [numberRows_];
    newDropped=cholesky_->factorize(diagonal_,rowsDroppedThisTime);
    if (newDropped) {
      if (newDropped==-1) {
	printf("Out of memory\n");
	problemStatus_=4;
	//delete all temporary regions
	deleteWorkingData();
	if (saveMatrix) {
	  // restore normal copy
	  delete matrix_;
	  matrix_ = saveMatrix;
	}
	return -1;
      } else {
#ifndef NDEBUG
	//int newDropped2=cholesky_->factorize(diagonal_,rowsDroppedThisTime);
	//assert(!newDropped2);
#endif
	if (newDropped<0&&0) {
	  //replace dropped
	  newDropped=-newDropped;
	  //off 1 to allow for reset all
	  newDropped--;
	  //set all bits false
	  cholesky_->resetRowsDropped();
	} 
      }
    } 
    delete [] rowsDroppedThisTime;
    if (cholesky_->status()) {
      std::cout << "bad cholesky?" <<std::endl;
      abort();
    }
    int phase=0; // predictor, corrector , primal dual
    CoinWorkDouble directionAccuracy=0.0;
    bool doCorrector=true;
    bool goodMove=true;
    //set up for affine direction
    setupForSolve(phase);
    if ((modeSwitch&2)==0) {
      directionAccuracy=findDirectionVector(phase);
      if (directionAccuracy>worstDirectionAccuracy_) {
	worstDirectionAccuracy_=directionAccuracy;
      }
      if (saveIteration>0&&directionAccuracy>1.0) {
	handler_->message(CLP_BARRIER_EXIT2,messages_)
	  <<saveIteration
	  <<CoinMessageEol;
	break;
      }
      findStepLength(phase);
      nextGap=complementarityGap(nextNumber,nextNumberItems,1);
      debugMove(0,actualPrimalStep_,actualDualStep_);
      debugMove(0,1.0e-2,1.0e-2);
    }
    CoinWorkDouble affineGap=nextGap;
    int bestPhase=0;
    CoinWorkDouble bestNextGap=nextGap;
    // ?
    bestNextGap=CoinMax(nextGap,0.8*complementarityGap_);
    if (quadraticObj)
      bestNextGap=CoinMax(nextGap,0.99*complementarityGap_);
    if (complementarityGap_>1.0e-4*numberComplementarityPairs_) {
      //std::cout <<"predicted duality gap "<<nextGap<<std::endl;
      CoinWorkDouble part1=nextGap/numberComplementarityPairs_;
      part1=nextGap/numberComplementarityItems_;
      CoinWorkDouble part2=nextGap/complementarityGap_;
      mu_=part1*part2*part2;
#if 0
      CoinWorkDouble papermu =complementarityGap_/numberComplementarityPairs_;
      CoinWorkDouble affmu = nextGap/nextNumber;
      CoinWorkDouble sigma = pow(affmu/papermu,3);
      printf("mu %g, papermu %g, affmu %g, sigma %g sigmamu %g\n",
	     mu_,papermu,affmu,sigma,sigma*papermu);
#endif
      //printf("paper mu %g\n",(nextGap*nextGap*nextGap)/(complementarityGap_*complementarityGap_*
      //					    (CoinWorkDouble) numberComplementarityPairs_));
    } else {
      CoinWorkDouble phi;
      if (numberComplementarityPairs_<=5000) {
	phi=pow(static_cast<CoinWorkDouble> (numberComplementarityPairs_),2.0);
      } else {
	phi=pow(static_cast<CoinWorkDouble> (numberComplementarityPairs_),1.5);
	if (phi<500.0*500.0) {
	  phi=500.0*500.0;
	} 
      }
      mu_=complementarityGap_/phi;
    } 
    //save information
    CoinWorkDouble product=affineProduct();
#if 0
    //can we do corrector step?
    CoinWorkDouble xx= complementarityGap_*(beta2-tau) +product;
    if (xx>0.0) {
      CoinWorkDouble saveMu = mu_;
      CoinWorkDouble mu2=numberComplementarityPairs_;
      mu2=xx/mu2;
      if (mu2>mu_) {
	//std::cout<<" could increase to "<<mu2<<std::endl;
	//was mu2=mu2*0.25;
	mu2=mu2*0.99;
	if (mu2<mu_) {
	  mu_=mu2;
	  //std::cout<<" changing mu to "<<mu_<<std::endl;
	} else {
	  //std::cout<<std::endl;
	} 
      } else {
	//std::cout<<" should decrease to "<<mu2<<std::endl;
	mu_=0.5*mu2;
	//std::cout<<" changing mu to "<<mu_<<std::endl;
      } 
      handler_->message(CLP_BARRIER_MU,messages_)
	<<saveMu<<mu_
	<<CoinMessageEol;
    } else {
      //std::cout<<" bad by any standards"<<std::endl;
    }
#endif 
    if (complementarityGap_*(beta2-tau)+product-mu_*numberComplementarityPairs_<0.0&&0) {
#ifdef SOME_DEBUG
      printf("failed 1 product %.18g mu %.18g - %.18g < 0.0, nextGap %.18g\n",product,mu_,
	     complementarityGap_*(beta2-tau)+product-mu_*numberComplementarityPairs_,
	     nextGap);
#endif
      doCorrector=false;
      if (nextGap>0.9*complementarityGap_||1) {
	goodMove=false;
	bestNextGap=COIN_DBL_MAX;
      }
      //CoinWorkDouble floatNumber = 2.0*numberComplementarityPairs_;
      //floatNumber = 1.0*numberComplementarityItems_;
      //mu_=nextGap/floatNumber;
      handler_->message(CLP_BARRIER_INFO,messages_)
	<<"no corrector step"
	<<CoinMessageEol;
    } else {
      phase=1;
    }
    // If bad gap - try standard primal dual
    if (nextGap>complementarityGap_*1.001)
      goodMove=false;
    if ((modeSwitch&2)!=0)
      goodMove=false;
    if (goodMove&&doCorrector) {
      CoinMemcpyN(deltaX_,numberTotal,saveX);
      CoinMemcpyN(deltaY_,numberRows_,saveY);
      CoinMemcpyN(deltaZ_,numberTotal,saveZ);
      CoinMemcpyN(deltaW_,numberTotal,saveW);
      CoinMemcpyN(deltaSL_,numberTotal,saveSL);
      CoinMemcpyN(deltaSU_,numberTotal,saveSU);
#ifdef HALVE
      CoinWorkDouble savePrimalStep = actualPrimalStep_;
      CoinWorkDouble saveDualStep = actualDualStep_;
      CoinWorkDouble saveMu = mu_;
#endif
      //set up for next step
      setupForSolve(phase);
      CoinWorkDouble directionAccuracy2=findDirectionVector(phase);
      if (directionAccuracy2>worstDirectionAccuracy_) {
	worstDirectionAccuracy_=directionAccuracy2;
      } 
      CoinWorkDouble testValue=1.0e2*directionAccuracy;
      if (1.0e2*projectionTolerance_>testValue) {
	testValue=1.0e2*projectionTolerance_;
      } 
      if (primalTolerance()>testValue) {
	testValue=primalTolerance();
      } 
      if (maximumRHSError_>testValue) {
	testValue=maximumRHSError_;
      } 
      if (directionAccuracy2>testValue&&numberIterations_>=-77) {
	goodMove=false;
#ifdef SOME_DEBUG
	printf("accuracy %g phase 1 failed, test value %g\n",
	       directionAccuracy2,testValue);
#endif
      } 
      if (goodMove) {
	phase=1;
	CoinWorkDouble norm = findStepLength(phase);
	nextGap = complementarityGap(nextNumber,nextNumberItems,1);
	debugMove(1,actualPrimalStep_,actualDualStep_);
	//debugMove(1,1.0e-7,1.0e-7);
	goodMove=checkGoodMove(true,bestNextGap,allowIncreasingGap);
	if (norm<0)
	  goodMove=false;
	if (!goodMove) {
#ifdef SOME_DEBUG
	  printf("checkGoodMove failed\n");
#endif
	}
      }
#ifdef HALVE
      int nHalve=0;
      // relax test
      bestNextGap=CoinMax(bestNextGap,0.9*complementarityGap_);
      while (!goodMove) {
	mu_=saveMu;
	actualPrimalStep_ = savePrimalStep;
	actualDualStep_ = saveDualStep;
	int i;
	//printf("halve %d\n",nHalve);
	nHalve++;
	const CoinWorkDouble lambda=0.5;
	for (i=0;i<numberRows_;i++)
	  deltaY_[i] = lambda*deltaY_[i]+(1.0-lambda)*saveY[i];
	for (i=0;i<numberTotal;i++) {
	  deltaX_[i] = lambda*deltaX_[i]+(1.0-lambda)*saveX[i];
	  deltaZ_[i] = lambda*deltaZ_[i]+(1.0-lambda)*saveZ[i];
	  deltaW_[i] = lambda*deltaW_[i]+(1.0-lambda)*saveW[i];
	  deltaSL_[i] = lambda*deltaSL_[i]+(1.0-lambda)*saveSL[i];
	  deltaSU_[i] = lambda*deltaSU_[i]+(1.0-lambda)*saveSU[i];
	}
   CoinMemcpyN(saveX,numberTotal,deltaX_);
   CoinMemcpyN(saveY,numberRows_,deltaY_);
   CoinMemcpyN(saveZ,numberTotal,deltaZ_);
   CoinMemcpyN(saveW,numberTotal,deltaW_);
   CoinMemcpyN(saveSL,numberTotal,deltaSL_);
   CoinMemcpyN(saveSU,numberTotal,deltaSU_);
	findStepLength(1);
	nextGap = complementarityGap(nextNumber,nextNumberItems,1);
	goodMove=checkGoodMove(true,bestNextGap,allowIncreasingGap);
	if (nHalve>10)
	  break;
	//assert (goodMove);
      }
      if (nHalve&&handler_->logLevel()>1) 
	printf("halved %d times\n",nHalve);
#endif
    }
    //bestPhase=-1;
    //goodMove=false;
    if (!goodMove) {
      // Just primal dual step
      CoinWorkDouble floatNumber;
      floatNumber = 2.0*numberComplementarityPairs_;
      //floatNumber = numberComplementarityItems_;
      CoinWorkDouble saveMu=mu_; // use one from predictor corrector
      mu_=complementarityGap_/floatNumber;
      // If going well try small mu
      mu_ *= CoinSqrt((1.0-lastStep)/(1.0+10.0*lastStep));
      CoinWorkDouble mu1=mu_;
      CoinWorkDouble phi;
      if (numberComplementarityPairs_<=500) {
	phi=pow(static_cast<CoinWorkDouble> (numberComplementarityPairs_),2.0);
      } else {
	phi=pow(static_cast<CoinWorkDouble> (numberComplementarityPairs_),1.5);
	if (phi<500.0*500.0) {
	  phi=500.0*500.0;
	} 
      }
      mu_=complementarityGap_/phi;
      //printf("pd mu %g, alternate %g, smallest %g\n",
      //     mu_,mu1,smallestPrimalDualMu);
      mu_ = CoinSqrt(mu_*mu1);
      mu_=mu1;
      if ((numberIterations_&1)==0||numberIterations_<10)
	mu_=saveMu;
      //mu_=CoinMin(smallestPrimalDualMu*0.95,mu_);
      smallestPrimalDualMu = mu_;
      // Try simpler
      floatNumber = numberComplementarityItems_;
      mu_=0.5*complementarityGap_/floatNumber;
      //if ((modeSwitch&2)==0) {
      //if ((numberIterations_&1)==0)
      //  mu_ *= 0.5;
      //} else {
      //mu_ *= 0.8;
      //}
      //set up for next step
      setupForSolve(2);
      findDirectionVector(2);
      CoinWorkDouble norm=findStepLength(2);
      // just for debug
      bestNextGap = complementarityGap_*1.0005;
      //bestNextGap=COIN_DBL_MAX;
      nextGap=complementarityGap(nextNumber,nextNumberItems,2);
      debugMove(2,actualPrimalStep_,actualDualStep_);
      //debugMove(2,1.0e-7,1.0e-7);
      checkGoodMove(false, bestNextGap,allowIncreasingGap);
      if ((nextGap>0.9*complementarityGap_&&bestPhase==0&&affineGap<nextGap
	  &&(numberIterations_>80||(numberIterations_>20&&quadraticObj)))||norm<0.0) {
	// Back to affine
	phase=0;
	setupForSolve(phase);
	directionAccuracy=findDirectionVector(phase);
	findStepLength(phase);
	nextGap=complementarityGap(nextNumber,nextNumberItems,1);
	bestNextGap = complementarityGap_;
	//checkGoodMove(false, bestNextGap,allowIncreasingGap);
      }
    }
    if (numberIterations_==0)
      smallestPrimalDualMu=mu_;
    if (!goodMove)
      mu_=nextGap / (static_cast<CoinWorkDouble> (nextNumber)*1.1);
    //if (quadraticObj)
    //goodMove=true; 
    //goodMove=false; //TEMP
    // Do centering steps
    int numberTries=0;
    CoinWorkDouble nextCenterGap=0.0;
    int numberGoodTries=0;
    CoinWorkDouble originalDualStep=actualDualStep_;
    CoinWorkDouble originalPrimalStep=actualPrimalStep_;
    if (actualDualStep_>0.9&&actualPrimalStep_>0.9)
      goodMove=false; // don't bother
    if ((modeSwitch&1)!=0)
      goodMove=false;
    while (goodMove&&numberTries<5) {
      goodMove=false;
      numberTries++;
      CoinMemcpyN(deltaX_,numberTotal,saveX);
      CoinMemcpyN(deltaY_,numberRows_,saveY);
      CoinMemcpyN(deltaZ_,numberTotal,saveZ);
      CoinMemcpyN(deltaW_,numberTotal,saveW);
      CoinWorkDouble savePrimalStep = actualPrimalStep_;
      CoinWorkDouble saveDualStep = actualDualStep_;
      CoinWorkDouble saveMu = mu_;
      setupForSolve(3);
      findDirectionVector(3);
      findStepLength(3);
      debugMove(3,actualPrimalStep_,actualDualStep_);
      //debugMove(3,1.0e-7,1.0e-7);
      CoinWorkDouble xGap = complementarityGap(nextNumber,nextNumberItems,3);
      // If one small then that's the one that counts
      CoinWorkDouble checkDual=saveDualStep;
      CoinWorkDouble checkPrimal=savePrimalStep;
      if (checkDual>5.0*checkPrimal) {
	checkDual=2.0*checkPrimal;
      } else if (checkPrimal>5.0*checkDual) {
	checkPrimal=2.0*checkDual;
      }
      if (actualPrimalStep_<checkPrimal||
	  actualDualStep_<checkDual||
	  (xGap>nextGap&&xGap>0.9*complementarityGap_)) {
	//if (actualPrimalStep_<=checkPrimal||
	//actualDualStep_<=checkDual) {
#ifdef SOME_DEBUG
	printf("PP rejected gap %.18g, steps %.18g %.18g, 2 gap %.18g, steps %.18g %.18g\n",xGap,
	       actualPrimalStep_,actualDualStep_,nextGap,savePrimalStep,saveDualStep);
#endif
	mu_=saveMu;
	actualPrimalStep_ = savePrimalStep;
	actualDualStep_ = saveDualStep;
 CoinMemcpyN(saveX,numberTotal,deltaX_);
 CoinMemcpyN(saveY,numberRows_,deltaY_);
 CoinMemcpyN(saveZ,numberTotal,deltaZ_);
 CoinMemcpyN(saveW,numberTotal,deltaW_);
      } else {
#ifdef SOME_DEBUG
	printf("PPphase 3 gap %.18g, steps %.18g %.18g, 2 gap %.18g, steps %.18g %.18g\n",xGap,
	       actualPrimalStep_,actualDualStep_,nextGap,savePrimalStep,saveDualStep);
#endif
	numberGoodTries++;
	nextCenterGap=xGap;
	// See if big enough change
	if (actualPrimalStep_<1.01*checkPrimal||
	    actualDualStep_<1.01*checkDual) {
	  // stop now
	} else {
	  // carry on
	  goodMove=true;
	}
      }
    }
    if (numberGoodTries&&handler_->logLevel()>1) {
      printf("%d centering steps moved from (gap %.18g, dual %.18g, primal %.18g) to (gap %.18g, dual %.18g, primal %.18g)\n",
	     numberGoodTries,static_cast<double>(nextGap),static_cast<double>(originalDualStep),
	     static_cast<double>(originalPrimalStep),
	     static_cast<double>(nextCenterGap), static_cast<double>(actualDualStep_),
	     static_cast<double>(actualPrimalStep_));
    }
    // save last gap
    checkGap = complementarityGap_;
    numberFixed=updateSolution(nextGap);
    numberFixedTotal+=numberFixed;
  } /* endwhile */
  delete [] saveX;
  delete [] saveY;
  delete [] saveZ;
  delete [] saveW;
  delete [] saveSL;
  delete [] saveSU;
  if (savePi) {
    if (numberIterations_-saveIteration>20&&
	numberIterations_-saveIteration2<5) { 
#if KEEP_GOING_IF_FIXED<10
      std::cout<<"Restoring2 from iteration "<<saveIteration2<<std::endl;
#endif
      CoinMemcpyN(savePi2,numberRows_,dualArray);
      CoinMemcpyN(savePrimal2,numberTotal,solution_);
    } else {
#if KEEP_GOING_IF_FIXED<10
      std::cout<<"Restoring from iteration "<<saveIteration<<std::endl;
#endif
      CoinMemcpyN(savePi,numberRows_,dualArray);
      CoinMemcpyN(savePrimal,numberTotal,solution_);
    }
    delete [] savePi;
    delete [] savePrimal;
  } 
  delete [] savePi2;
  delete [] savePrimal2;
  //recompute slacks
  // Split out solution
  CoinZeroN(rowActivity_,numberRows_);
  CoinMemcpyN(solution_,numberColumns_,columnActivity_);
  matrix_->times(1.0,columnActivity_,rowActivity_);
  //unscale objective
  multiplyAdd(NULL,numberTotal,0.0,cost_,scaleFactor_);
  multiplyAdd(NULL,numberRows_,0,dualArray,scaleFactor_);
  checkSolution();
  //CoinMemcpyN(reducedCost_,numberColumns_,dj_);
  // If quadratic use last solution 
  // Restore quadratic objective if necessary
  if (saveObjective) {
    delete objective_;
    objective_=saveObjective;
    objectiveValue_=0.5*(primalObjective_+dualObjective_);
  }
  handler_->message(CLP_BARRIER_END,messages_)
    <<static_cast<double>(sumPrimalInfeasibilities_)
    <<static_cast<double>(sumDualInfeasibilities_)
    <<static_cast<double>(complementarityGap_)
    <<static_cast<double>(objectiveValue())
    <<CoinMessageEol;
  //#ifdef SOME_DEBUG
  if (handler_->logLevel()>1) 
    printf("ENDRUN status %d after %d iterations\n",problemStatus_,numberIterations_);
  //#endif
  //std::cout<<"Absolute primal infeasibility at end "<<sumPrimalInfeasibilities_<<std::endl;
  //std::cout<<"Absolute dual infeasibility at end "<<sumDualInfeasibilities_<<std::endl;
  //std::cout<<"Absolute complementarity at end "<<complementarityGap_<<std::endl;
  //std::cout<<"Primal objective "<<objectiveValue()<<std::endl;
  //std::cout<<"maximum complementarity "<<worstComplementarity_<<std::endl;
#if COIN_LONG_WORK 
  // put back dual
  delete [] dual_;
  delete [] reducedCost_;
  dual_ = dualSave;
  reducedCost_=reducedCostSave;
#endif
  //delete all temporary regions
  deleteWorkingData();
#if KEEP_GOING_IF_FIXED<10
#if 0 //ndef NDEBUG
  {
    static int kk=0;
    char name[20];
    sprintf(name,"save.sol.%d",kk);
    kk++;
    printf("saving to file %s\n",name);
    FILE * fp = fopen(name,"wb");
    int numberWritten;
    numberWritten = fwrite(&numberColumns_,sizeof(int),1,fp);
    assert (numberWritten==1);
    numberWritten = fwrite(columnActivity_,sizeof(double),numberColumns_,fp);
    assert (numberWritten==numberColumns_);
    fclose(fp);
  }
#endif
#endif
  if (saveMatrix) {
    // restore normal copy
    delete matrix_;
    matrix_ = saveMatrix;
  }
  return problemStatus_;
}
// findStepLength.
//phase  - 0 predictor
//         1 corrector
//         2 primal dual
CoinWorkDouble ClpPredictorCorrector::findStepLength( int phase)
{
  CoinWorkDouble directionNorm=0.0;
  CoinWorkDouble maximumPrimalStep=COIN_DBL_MAX*1.0e-20;
  CoinWorkDouble maximumDualStep=COIN_DBL_MAX;
  int numberTotal = numberRows_+numberColumns_;
  CoinWorkDouble tolerance = 1.0e-12;
  int chosenPrimalSequence=-1;
  int chosenDualSequence=-1;
  bool lowPrimal=false;
  bool lowDual=false;
  // If done many iterations then allow to hit boundary
  CoinWorkDouble hitTolerance;
  //printf("objective norm %g\n",objectiveNorm_);
  if (numberIterations_<80||!gonePrimalFeasible_)
    hitTolerance = COIN_DBL_MAX;
  else
    hitTolerance = CoinMax(1.0e3,1.0e-3*objectiveNorm_);
  int iColumn;
  //printf("dual value %g\n",dual_[0]);
  //printf("     X     dX      lS     dlS     uS     dUs    dj    Z dZ     t   dT\n"); 
  for (iColumn=0;iColumn<numberTotal;iColumn++) {
    if (!flagged(iColumn)) {
      CoinWorkDouble directionElement=deltaX_[iColumn];
      if (directionNorm<CoinAbs(directionElement)) {
	directionNorm=CoinAbs(directionElement);
      }
      if (lowerBound(iColumn)) {
	CoinWorkDouble delta = - deltaSL_[iColumn];
	CoinWorkDouble z1 = deltaZ_[iColumn];
	CoinWorkDouble newZ = zVec_[iColumn]+z1;
	if (zVec_[iColumn]>tolerance) {
	  if (zVec_[iColumn]<-z1*maximumDualStep) {
	    maximumDualStep=-zVec_[iColumn]/z1;
	    chosenDualSequence=iColumn;
	    lowDual=true;
	  } 
	} 
	if (lowerSlack_[iColumn]<maximumPrimalStep*delta) {
	  CoinWorkDouble newStep=lowerSlack_[iColumn]/delta;
	  if (newStep>0.2||newZ<hitTolerance||delta>1.0e3||delta<=1.0e-6||dj_[iColumn]<hitTolerance) {
	    maximumPrimalStep = newStep;
	    chosenPrimalSequence=iColumn;
	    lowPrimal=true;
	  } else {
	    //printf("small %d delta %g newZ %g step %g\n",iColumn,delta,newZ,newStep); 
	  }
	} 
      }
      if (upperBound(iColumn)) {
	CoinWorkDouble delta = - deltaSU_[iColumn];;
	CoinWorkDouble w1 = deltaW_[iColumn];
	CoinWorkDouble newT = wVec_[iColumn]+w1;
	if (wVec_[iColumn]>tolerance) {
	  if (wVec_[iColumn]<-w1*maximumDualStep) {
	    maximumDualStep=-wVec_[iColumn]/w1;
	    chosenDualSequence=iColumn;
	    lowDual=false;
	  } 
	} 
	if (upperSlack_[iColumn]<maximumPrimalStep*delta) {
	  CoinWorkDouble newStep=upperSlack_[iColumn]/delta;
	  if (newStep>0.2||newT<hitTolerance||delta>1.0e3||delta<=1.0e-6||dj_[iColumn]>-hitTolerance) {
	    maximumPrimalStep = newStep;
	    chosenPrimalSequence=iColumn;
	    lowPrimal=false;
	  } else {
	    //printf("small %d delta %g newT %g step %g\n",iColumn,delta,newT,newStep); 
	  }
	} 
      } 
    } 
  }
#ifdef SOME_DEBUG
  printf("new step - phase %d, norm %.18g, dual step %.18g, primal step %.18g\n",
	 phase,directionNorm,maximumDualStep,maximumPrimalStep);
  if (lowDual) 
    printf("ld %d %g %g => %g (dj %g,sol %g) ",
	   chosenDualSequence,zVec_[chosenDualSequence],
	   deltaZ_[chosenDualSequence],zVec_[chosenDualSequence]+
	   maximumDualStep*deltaZ_[chosenDualSequence],dj_[chosenDualSequence],
	   solution_[chosenDualSequence]);
  else
    printf("ud %d %g %g => %g (dj %g,sol %g) ",
	   chosenDualSequence,wVec_[chosenDualSequence],
	   deltaW_[chosenDualSequence],wVec_[chosenDualSequence]+
	   maximumDualStep*deltaW_[chosenDualSequence],dj_[chosenDualSequence],
	   solution_[chosenDualSequence]);
  if (lowPrimal) 
    printf("lp %d %g %g => %g (dj %g,sol %g)\n",
	   chosenPrimalSequence,lowerSlack_[chosenPrimalSequence],
	   deltaSL_[chosenPrimalSequence],lowerSlack_[chosenPrimalSequence]+
	   maximumPrimalStep*deltaSL_[chosenPrimalSequence],
	   dj_[chosenPrimalSequence],solution_[chosenPrimalSequence]);
  else
    printf("up %d %g %g => %g (dj %g,sol %g)\n",
	   chosenPrimalSequence,upperSlack_[chosenPrimalSequence],
	   deltaSU_[chosenPrimalSequence],upperSlack_[chosenPrimalSequence]+
	   maximumPrimalStep*deltaSU_[chosenPrimalSequence],
	   dj_[chosenPrimalSequence],solution_[chosenPrimalSequence]);
#endif
  actualPrimalStep_=stepLength_*maximumPrimalStep;
  if (phase>=0&&actualPrimalStep_>1.0) {
    actualPrimalStep_=1.0;
  } 
  actualDualStep_=stepLength_*maximumDualStep;
  if (phase>=0&&actualDualStep_>1.0) {
    actualDualStep_=1.0;
  } 
  // See if quadratic objective
#ifndef NO_RTTI
  ClpQuadraticObjective * quadraticObj = (dynamic_cast< ClpQuadraticObjective*>(objective_));
#else
  ClpQuadraticObjective * quadraticObj = NULL;
  if (objective_->type()==2)
    quadraticObj = (static_cast< ClpQuadraticObjective*>(objective_));
#endif
  if (quadraticObj) {
    // Use smaller unless very small
    CoinWorkDouble smallerStep=CoinMin(actualDualStep_,actualPrimalStep_);
    if (smallerStep>0.0001) {
      actualDualStep_=smallerStep;
      actualPrimalStep_=smallerStep;
    }
  }
#define OFFQ
#ifndef OFFQ
  if (quadraticObj) {
    // Don't bother if phase 0 or 3 or large gap
    //if ((phase==1||phase==2||phase==0)&&maximumDualError_>0.1*complementarityGap_
    //&&smallerStep>0.001) {
    if ((phase==1||phase==2||phase==0||phase==3)) {
      // minimize complementarity + norm*dual inf ? primal inf
      // at first - just check better - if not 
      // Complementarity gap will be a*change*change + b*change +c
      CoinWorkDouble a=0.0;
      CoinWorkDouble b=0.0;
      CoinWorkDouble c=0.0;
      /* SQUARE of dual infeasibility will be:
	 square of dj - ......
      */
      CoinWorkDouble aq=0.0;
      CoinWorkDouble bq=0.0;
      CoinWorkDouble cq=0.0;
      CoinWorkDouble gamma2 = gamma_*gamma_; // gamma*gamma will be added to diagonal
      CoinWorkDouble * linearDjChange = new CoinWorkDouble[numberTotal];
      CoinZeroN(linearDjChange,numberColumns_);
      multiplyAdd(deltaY_,numberRows_,1.0,linearDjChange+numberColumns_,0.0);
      matrix_->transposeTimes(-1.0,deltaY_,linearDjChange);
      CoinPackedMatrix * quadratic = quadraticObj->quadraticObjective();
      const int * columnQuadratic = quadratic->getIndices();
      const CoinBigIndex * columnQuadraticStart = quadratic->getVectorStarts();
      const int * columnQuadraticLength = quadratic->getVectorLengths();
      CoinWorkDouble * quadraticElement = quadratic->getMutableElements();
      for (iColumn=0;iColumn<numberTotal;iColumn++) {
	CoinWorkDouble oldPrimal = solution_[iColumn];
	if (!flagged(iColumn)) {
	  if (lowerBound(iColumn)) {
	    CoinWorkDouble change =oldPrimal+deltaX_[iColumn]-lowerSlack_[iColumn]-lower_[iColumn];
	    c += lowerSlack_[iColumn]*zVec_[iColumn];
	    b += lowerSlack_[iColumn]*deltaZ_[iColumn]+zVec_[iColumn]*change;
	    a += deltaZ_[iColumn]*change;
	  }
	  if (upperBound(iColumn)) {
	    CoinWorkDouble change =upper_[iColumn]-oldPrimal-deltaX_[iColumn]-upperSlack_[iColumn];
	    c += upperSlack_[iColumn]*wVec_[iColumn];
	    b += upperSlack_[iColumn]*deltaW_[iColumn]+wVec_[iColumn]*change;
	    a += deltaW_[iColumn]*change;
	  } 
	  // new djs are dj_ + change*value
	  CoinWorkDouble djChange = linearDjChange[iColumn];
	  if (iColumn<numberColumns_) {
	    for (CoinBigIndex j=columnQuadraticStart[iColumn];
		 j<columnQuadraticStart[iColumn]+columnQuadraticLength[iColumn];j++) {
	      int jColumn = columnQuadratic[j];
	      CoinWorkDouble changeJ = deltaX_[jColumn];
	      CoinWorkDouble elementValue = quadraticElement[j];
	      djChange += changeJ*elementValue;
	    }
	  }
	  CoinWorkDouble gammaTerm = gamma2;
	  if (primalR_) {
	    gammaTerm += primalR_[iColumn];
	  }
	  djChange += gammaTerm;
	  // and dual infeasibility
	  CoinWorkDouble oldInf = dj_[iColumn]-zVec_[iColumn]+wVec_[iColumn]+
	    gammaTerm*solution_[iColumn];
	  CoinWorkDouble changeInf = djChange-deltaZ_[iColumn]+deltaW_[iColumn];
	  cq += oldInf*oldInf;
	  bq += 2.0*oldInf*changeInf;
	  aq += changeInf*changeInf;
	} else {
	  // fixed
	  if (lowerBound(iColumn)) {
	    c += lowerSlack_[iColumn]*zVec_[iColumn];
	  }
	  if (upperBound(iColumn)) {
	    c += upperSlack_[iColumn]*wVec_[iColumn];
	  } 
	  // new djs are dj_ + change*value
	  CoinWorkDouble djChange = linearDjChange[iColumn];
	  if (iColumn<numberColumns_) {
	    for (CoinBigIndex j=columnQuadraticStart[iColumn];
		 j<columnQuadraticStart[iColumn]+columnQuadraticLength[iColumn];j++) {
	      int jColumn = columnQuadratic[j];
	      CoinWorkDouble changeJ = deltaX_[jColumn];
	      CoinWorkDouble elementValue = quadraticElement[j];
	      djChange += changeJ*elementValue;
	    }
	  }
	  CoinWorkDouble gammaTerm = gamma2;
	  if (primalR_) {
	    gammaTerm += primalR_[iColumn];
	  }
	  djChange += gammaTerm;
	  // and dual infeasibility
	  CoinWorkDouble oldInf = dj_[iColumn]-zVec_[iColumn]+wVec_[iColumn]+
	    gammaTerm*solution_[iColumn];
	  CoinWorkDouble changeInf = djChange-deltaZ_[iColumn]+deltaW_[iColumn];
	  cq += oldInf*oldInf;
	  bq += 2.0*oldInf*changeInf;
	  aq += changeInf*changeInf;
	}
      }
      delete [] linearDjChange;
      // ? We want to minimize complementarityGap + solutionNorm_*square of inf ??
      // maybe use inf and do line search
      // To check see if matches at current step
      CoinWorkDouble step=actualPrimalStep_;
      //Current gap + solutionNorm_ * CoinSqrt (sum square inf)
      CoinWorkDouble multiplier = solutionNorm_;
      multiplier *= 0.01;
      multiplier=1.0;
      CoinWorkDouble currentInf =  multiplier*CoinSqrt(cq);
      CoinWorkDouble nextInf = 	multiplier*CoinSqrt(CoinMax(cq+step*bq+step*step*aq,0.0));
      CoinWorkDouble allowedIncrease=1.4;
#ifdef SOME_DEBUG
      printf("lin %g %g %g -> %g\n",a,b,c,
	     c+b*step+a*step*step);
      printf("quad %g %g %g -> %g\n",aq,bq,cq,
	     cq+bq*step+aq*step*step);
      debugMove(7,step,step);
      printf ("current dualInf %g, with step of %g is %g\n",
	      currentInf,step,nextInf);
#endif
      if (b>-1.0e-6) {
	if (phase!=0)
	  directionNorm=-1.0;
      }
      if ((phase==1||phase==2||phase==0||phase==3)&&nextInf>0.1*complementarityGap_&&
	  nextInf>currentInf*allowedIncrease) {
	//cq = CoinMax(cq,10.0);
	// convert to (x+q)*(x+q) = w
	CoinWorkDouble q = bq/(1.0*aq);
	CoinWorkDouble w = CoinMax(q*q + (cq/aq)*(allowedIncrease-1.0),0.0);
	w = CoinSqrt(w);
	CoinWorkDouble stepX = w-q;
	step=stepX;
	nextInf = 
	  multiplier*CoinSqrt(CoinMax(cq+step*bq+step*step*aq,0.0));
#ifdef SOME_DEBUG
	printf ("with step of %g dualInf is %g\n",
		step,nextInf);
#endif
	actualDualStep_=CoinMin(step,actualDualStep_);
	actualPrimalStep_=CoinMin(step,actualPrimalStep_);
      }
    }
  } else {
    // probably pointless as linear
    // minimize complementarity 
    // Complementarity gap will be a*change*change + b*change +c
    CoinWorkDouble a=0.0;
    CoinWorkDouble b=0.0;
    CoinWorkDouble c=0.0;
    for (iColumn=0;iColumn<numberTotal;iColumn++) {
      CoinWorkDouble oldPrimal = solution_[iColumn];
      if (!flagged(iColumn)) {
	if (lowerBound(iColumn)) {
	  CoinWorkDouble change =oldPrimal+deltaX_[iColumn]-lowerSlack_[iColumn]-lower_[iColumn];
	  c += lowerSlack_[iColumn]*zVec_[iColumn];
	  b += lowerSlack_[iColumn]*deltaZ_[iColumn]+zVec_[iColumn]*change;
	  a += deltaZ_[iColumn]*change;
	}
	if (upperBound(iColumn)) {
	  CoinWorkDouble change =upper_[iColumn]-oldPrimal-deltaX_[iColumn]-upperSlack_[iColumn];
	  c += upperSlack_[iColumn]*wVec_[iColumn];
	  b += upperSlack_[iColumn]*deltaW_[iColumn]+wVec_[iColumn]*change;
	  a += deltaW_[iColumn]*change;
	} 
      } else {
	// fixed
	if (lowerBound(iColumn)) {
	  c += lowerSlack_[iColumn]*zVec_[iColumn];
	}
	if (upperBound(iColumn)) {
	  c += upperSlack_[iColumn]*wVec_[iColumn];
	} 
      }
    }
    // ? We want to minimize complementarityGap;
    // maybe use inf and do line search
    // To check see if matches at current step
    CoinWorkDouble step=CoinMin(actualPrimalStep_,actualDualStep_);
    CoinWorkDouble next = c+b*step+a*step*step;
#ifdef SOME_DEBUG
    printf("lin %g %g %g -> %g\n",a,b,c,
	   c+b*step+a*step*step);
    debugMove(7,step,step);
#endif
    if (b>-1.0e-6) {
      if (phase==0) {
#ifdef SOME_DEBUG
	printf("*** odd phase 0 direction\n");
#endif
      } else {
	directionNorm=-1.0;
      }
    }
    // and with ratio
    a=0.0;
    b=0.0;
    CoinWorkDouble ratio = actualDualStep_/actualPrimalStep_;
    for (iColumn=0;iColumn<numberTotal;iColumn++) {
      CoinWorkDouble oldPrimal = solution_[iColumn];
      if (!flagged(iColumn)) {
	if (lowerBound(iColumn)) {
	  CoinWorkDouble change =oldPrimal+deltaX_[iColumn]-lowerSlack_[iColumn]-lower_[iColumn];
	  b += lowerSlack_[iColumn]*deltaZ_[iColumn]*ratio+zVec_[iColumn]*change;
	  a += deltaZ_[iColumn]*change*ratio;
	}
	if (upperBound(iColumn)) {
	  CoinWorkDouble change =upper_[iColumn]-oldPrimal-deltaX_[iColumn]-upperSlack_[iColumn];
	  b += upperSlack_[iColumn]*deltaW_[iColumn]*ratio+wVec_[iColumn]*change;
	  a += deltaW_[iColumn]*change*ratio;
	} 
      }
    }
    // ? We want to minimize complementarityGap;
    // maybe use inf and do line search
    // To check see if matches at current step
    step=actualPrimalStep_;
    CoinWorkDouble next2 = c+b*step+a*step*step;
    if (next2>next) {
      actualPrimalStep_=CoinMin(actualPrimalStep_,actualDualStep_);
      actualDualStep_=actualPrimalStep_;
    }
#ifdef SOME_DEBUG
    printf("linb %g %g %g -> %g\n",a,b,c,
	   c+b*step+a*step*step);
    debugMove(7,actualPrimalStep_,actualDualStep_);
#endif
    if (b>-1.0e-6) {
      if (phase==0) {
#ifdef SOME_DEBUG
	printf("*** odd phase 0 direction\n");
#endif
      } else {
	directionNorm=-1.0;
      }
    }
  }
#else
  //actualPrimalStep_ =0.5*actualDualStep_;
#endif
#ifdef FULL_DEBUG
  if (phase==3){
    CoinWorkDouble minBeta = 0.1*mu_;
    CoinWorkDouble maxBeta = 10.0*mu_;
    for (iColumn=0;iColumn<numberRows_+numberColumns_;iColumn++) {
      if (!flagged(iColumn)) {
	if (lowerBound(iColumn)) {
	  CoinWorkDouble change = -rhsL_[iColumn] + deltaX_[iColumn];
	  CoinWorkDouble dualValue=zVec_[iColumn]+actualDualStep_*deltaZ_[iColumn];
	  CoinWorkDouble primalValue=lowerSlack_[iColumn]+actualPrimalStep_*change;
	  CoinWorkDouble gapProduct=dualValue*primalValue;
	  if (delta2Z_[iColumn]<minBeta||delta2Z_[iColumn]>maxBeta)
	    printf("3lower %d primal %g, dual %g, gap %g, old gap %g\n",
		   iColumn,primalValue,dualValue,gapProduct,delta2Z_[iColumn]);
	}  
	if (upperBound(iColumn)) {
	  CoinWorkDouble change = rhsU_[iColumn]-deltaX_[iColumn];
	  CoinWorkDouble dualValue=wVec_[iColumn]+actualDualStep_*deltaW_[iColumn];
	  CoinWorkDouble primalValue=upperSlack_[iColumn]+actualPrimalStep_*change;
	  CoinWorkDouble gapProduct=dualValue*primalValue;
	  if (delta2W_[iColumn]<minBeta||delta2W_[iColumn]>maxBeta)
	    printf("3upper %d primal %g, dual %g, gap %g, old gap %g\n",
		 iColumn,primalValue,dualValue,gapProduct,delta2W_[iColumn]);
	} 
      } 
    }
  }
#endif
#ifdef SOME_DEBUG_not
  {
    CoinWorkDouble largestL=0.0;
    CoinWorkDouble smallestL=COIN_DBL_MAX;
    CoinWorkDouble largestU=0.0;
    CoinWorkDouble smallestU=COIN_DBL_MAX;
    CoinWorkDouble sumL=0.0;
    CoinWorkDouble sumU=0.0;
    int nL=0;
    int nU=0;
    for (iColumn=0;iColumn<numberRows_+numberColumns_;iColumn++) {
      if (!flagged(iColumn)) {
	if (lowerBound(iColumn)) {
	  CoinWorkDouble change = -rhsL_[iColumn] + deltaX_[iColumn];
	  CoinWorkDouble dualValue=zVec_[iColumn]+actualDualStep_*deltaZ_[iColumn];
	  CoinWorkDouble primalValue=lowerSlack_[iColumn]+actualPrimalStep_*change;
	  CoinWorkDouble gapProduct=dualValue*primalValue;
	  largestL = CoinMax(largestL,gapProduct);
	  smallestL = CoinMin(smallestL,gapProduct);
	  nL++;
	  sumL += gapProduct;
	}  
	if (upperBound(iColumn)) {
	  CoinWorkDouble change = rhsU_[iColumn]-deltaX_[iColumn];
	  CoinWorkDouble dualValue=wVec_[iColumn]+actualDualStep_*deltaW_[iColumn];
	  CoinWorkDouble primalValue=upperSlack_[iColumn]+actualPrimalStep_*change;
	  CoinWorkDouble gapProduct=dualValue*primalValue;
	  largestU = CoinMax(largestU,gapProduct);
	  smallestU = CoinMin(smallestU,gapProduct);
	  nU++;
	  sumU += gapProduct;
	} 
      } 
    }
    CoinWorkDouble mu = (sumL+sumU)/(static_cast<CoinWorkDouble> (nL+nU));

    CoinWorkDouble minBeta = 0.1*mu;
    CoinWorkDouble maxBeta = 10.0*mu;
    int nBL=0;
    int nAL=0;
    int nBU=0;
    int nAU=0;
    for (iColumn=0;iColumn<numberRows_+numberColumns_;iColumn++) {
      if (!flagged(iColumn)) {
	if (lowerBound(iColumn)) {
	  CoinWorkDouble change = -rhsL_[iColumn] + deltaX_[iColumn];
	  CoinWorkDouble dualValue=zVec_[iColumn]+actualDualStep_*deltaZ_[iColumn];
	  CoinWorkDouble primalValue=lowerSlack_[iColumn]+actualPrimalStep_*change;
	  CoinWorkDouble gapProduct=dualValue*primalValue;
	  if (gapProduct<minBeta)
	    nBL++;
	  else if (gapProduct>maxBeta)
	    nAL++;
	  //if (gapProduct<0.1*minBeta)
	  //printf("Lsmall one %d dual %g primal %g\n",iColumn,
	  //   dualValue,primalValue);
	}  
	if (upperBound(iColumn)) {
	  CoinWorkDouble change = rhsU_[iColumn]-deltaX_[iColumn];
	  CoinWorkDouble dualValue=wVec_[iColumn]+actualDualStep_*deltaW_[iColumn];
	  CoinWorkDouble primalValue=upperSlack_[iColumn]+actualPrimalStep_*change;
	  CoinWorkDouble gapProduct=dualValue*primalValue;
	  if (gapProduct<minBeta)
	    nBU++;
	  else if (gapProduct>maxBeta)
	    nAU++;
	  //if (gapProduct<0.1*minBeta)
	  //printf("Usmall one %d dual %g primal %g\n",iColumn,
	  //   dualValue,primalValue);
	} 
      } 
    }
    printf("phase %d new mu %.18g new gap %.18g\n",phase,mu,sumL+sumU);
    printf("          %d lower, smallest %.18g, %d below - largest %.18g, %d above\n",
	   nL,smallestL,nBL,largestL,nAL);
    printf("          %d upper, smallest %.18g, %d below - largest %.18g, %d above\n",
	   nU,smallestU,nBU,largestU,nAU);
  }
#endif
  return directionNorm;
}
/* Does solve. region1 is for deltaX (columns+rows), region2 for deltaPi (rows) */
void 
ClpPredictorCorrector::solveSystem(CoinWorkDouble * region1, CoinWorkDouble * region2,
				   const CoinWorkDouble * region1In, const CoinWorkDouble * region2In,
				   const CoinWorkDouble * saveRegion1, const CoinWorkDouble * saveRegion2,
				   bool gentleRefine)
{
  int iRow;
  int numberTotal = numberRows_+numberColumns_;
  if (region2In) {
    // normal
    for (iRow=0;iRow<numberRows_;iRow++)
      region2[iRow] = region2In[iRow];
  } else {
    // initial solution - (diagonal is 1 or 0)
    CoinZeroN(region2,numberRows_);
  }
  int iColumn;
  if (cholesky_->type()<20) {
    // not KKT
    for (iColumn=0;iColumn<numberTotal;iColumn++)
      region1[iColumn] = region1In[iColumn]*diagonal_[iColumn];
    multiplyAdd(region1+numberColumns_,numberRows_,-1.0,region2,1.0);
    matrix_->times(1.0,region1,region2);
    CoinWorkDouble maximumRHS = maximumAbsElement(region2,numberRows_);
    CoinWorkDouble scale=1.0;
    CoinWorkDouble unscale=1.0;
    if (maximumRHS>1.0e-30) {
      if (maximumRHS<=0.5) {
	CoinWorkDouble factor=2.0;
	while (maximumRHS<=0.5) {
	  maximumRHS*=factor;
	  scale*=factor;
	} /* endwhile */
      } else if (maximumRHS>=2.0&&maximumRHS<=COIN_DBL_MAX) {
	CoinWorkDouble factor=0.5;
	while (maximumRHS>=2.0) {
	  maximumRHS*=factor;
	  scale*=factor;
	} /* endwhile */
      } 
      unscale=diagonalScaleFactor_/scale;
    } else {
      //effectively zero
      scale=0.0;
      unscale=0.0;
    } 
    multiplyAdd(NULL,numberRows_,0.0,region2,scale);
    cholesky_->solve(region2);
    multiplyAdd(NULL,numberRows_,0.0,region2,unscale);
    multiplyAdd(region2,numberRows_,-1.0,region1+numberColumns_,0.0);
    CoinZeroN(region1,numberColumns_);
    matrix_->transposeTimes(1.0,region2,region1);
    for (iColumn=0;iColumn<numberTotal;iColumn++)
      region1[iColumn] = (region1[iColumn]-region1In[iColumn])*diagonal_[iColumn];
  } else {
    for (iColumn=0;iColumn<numberTotal;iColumn++)
      region1[iColumn] = region1In[iColumn];
    cholesky_->solveKKT(region1,region2,diagonal_,diagonalScaleFactor_);
  }
  if (saveRegion2) {
    //refine?
    CoinWorkDouble scaleX=1.0;
    if (gentleRefine) 
      scaleX=0.8;
    multiplyAdd(saveRegion2,numberRows_,1.0,region2,scaleX);
    assert (saveRegion1);
    multiplyAdd(saveRegion1,numberTotal,1.0,region1,scaleX);
  } 
}
// findDirectionVector.
CoinWorkDouble ClpPredictorCorrector::findDirectionVector(const int phase)
{
  CoinWorkDouble projectionTolerance=projectionTolerance_;
  //temporary
  //projectionTolerance=1.0e-15;
  CoinWorkDouble errorCheck=0.9*maximumRHSError_/solutionNorm_;
  if (errorCheck>primalTolerance()) {
    if (errorCheck<projectionTolerance) {
      projectionTolerance=errorCheck;
    } 
  } else {
    if (primalTolerance()<projectionTolerance) {
      projectionTolerance=primalTolerance();
    } 
  } 
  CoinWorkDouble * newError = new CoinWorkDouble [numberRows_];
  int numberTotal = numberRows_+numberColumns_;
  //if flagged then entries zero so can do
  // For KKT separate out
  CoinWorkDouble * region1Save=NULL;//for refinement
  int iColumn;
  if (cholesky_->type()<20) {
    int iColumn;
    for (iColumn=0;iColumn<numberTotal;iColumn++)
      deltaX_[iColumn] = workArray_[iColumn] - solution_[iColumn];
    multiplyAdd(deltaX_+numberColumns_,numberRows_,-1.0,deltaY_,0.0);
    matrix_->times(1.0,deltaX_,deltaY_);
  } else {
    // regions in will be workArray and newError
    // regions out deltaX_ and deltaY_
    multiplyAdd(solution_+numberColumns_,numberRows_,1.0,newError,0.0);
    matrix_->times(-1.0,solution_,newError);
    // This is inefficient but just for now get values which will be in deltay
    int iColumn;
    for (iColumn=0;iColumn<numberTotal;iColumn++)
      deltaX_[iColumn] = workArray_[iColumn] - solution_[iColumn];
    multiplyAdd(deltaX_+numberColumns_,numberRows_,-1.0,deltaY_,0.0);
    matrix_->times(1.0,deltaX_,deltaY_);
  }
  bool goodSolve=false;
  CoinWorkDouble * regionSave=NULL;//for refinement
  int numberTries=0;
  CoinWorkDouble relativeError=COIN_DBL_MAX;
  CoinWorkDouble tryError=1.0e31;
  CoinWorkDouble saveMaximum=0.0;
  double firstError=0.0;
  double lastError2=0.0;
  while (!goodSolve&&numberTries<30) {
    CoinWorkDouble lastError=relativeError;
    goodSolve=true;
    CoinWorkDouble maximumRHS;
    maximumRHS = CoinMax(maximumAbsElement(deltaY_,numberRows_),1.0e-12);
    if (!numberTries)
      saveMaximum = maximumRHS;
    if (cholesky_->type()<20) {
      // no kkt
      CoinWorkDouble scale=1.0;
      CoinWorkDouble unscale=1.0;
      if (maximumRHS>1.0e-30) {
	if (maximumRHS<=0.5) {
	  CoinWorkDouble factor=2.0;
	  while (maximumRHS<=0.5) {
	    maximumRHS*=factor;
	    scale*=factor;
	  } /* endwhile */
	} else if (maximumRHS>=2.0&&maximumRHS<=COIN_DBL_MAX) {
	  CoinWorkDouble factor=0.5;
	  while (maximumRHS>=2.0) {
	    maximumRHS*=factor;
	    scale*=factor;
	  } /* endwhile */
	} 
	unscale=diagonalScaleFactor_/scale;
      } else {
	//effectively zero
	scale=0.0;
	unscale=0.0;
      } 
      //printf("--putting scales to 1.0\n");
      //scale=1.0;
      //unscale=1.0;
      multiplyAdd(NULL,numberRows_,0.0,deltaY_,scale);
      cholesky_->solve(deltaY_);
      multiplyAdd(NULL,numberRows_,0.0,deltaY_,unscale);
#if 0
      {
	printf("deltay\n");
	for (int i=0;i<numberRows_;i++) 
	  printf("%d %.18g\n",i,deltaY_[i]);
      }
      exit(66);
#endif
      if (numberTries) {
	//refine?
	CoinWorkDouble scaleX=1.0;
	if (lastError>1.0e-5) 
	  scaleX=0.8;
	multiplyAdd(regionSave,numberRows_,1.0,deltaY_,scaleX);
      } 
      //CoinZeroN(newError,numberRows_);
      multiplyAdd(deltaY_,numberRows_,-1.0,deltaX_+numberColumns_,0.0);
      CoinZeroN(deltaX_,numberColumns_);
      matrix_->transposeTimes(1.0,deltaY_,deltaX_);
      //if flagged then entries zero so can do
      for (iColumn=0;iColumn<numberTotal;iColumn++)
	deltaX_[iColumn] = deltaX_[iColumn]*diagonal_[iColumn]
	  -workArray_[iColumn];
    } else {
      // KKT
      solveSystem(deltaX_, deltaY_,
		  workArray_,newError,region1Save,regionSave,lastError>1.0e-5);
    }
    multiplyAdd(deltaX_+numberColumns_,numberRows_,-1.0,newError,0.0);
    matrix_->times(1.0,deltaX_,newError);
    numberTries++;
    
    //now add in old Ax - doing extra checking
    CoinWorkDouble maximumRHSError=0.0;
    CoinWorkDouble maximumRHSChange=0.0;
    int iRow;
    char * dropped = cholesky_->rowsDropped();
    for (iRow=0;iRow<numberRows_;iRow++) {
      if (!dropped[iRow]) {
	CoinWorkDouble newValue=newError[iRow];
	CoinWorkDouble oldValue=errorRegion_[iRow];
	//severity of errors depend on signs
	//**later                                                             */
	if (CoinAbs(newValue)>maximumRHSChange) {
	  maximumRHSChange=CoinAbs(newValue);
	} 
	CoinWorkDouble result=newValue+oldValue;
	if (CoinAbs(result)>maximumRHSError) {
	  maximumRHSError=CoinAbs(result);
	} 
	newError[iRow]=result;
      } else {
	CoinWorkDouble newValue=newError[iRow];
	CoinWorkDouble oldValue=errorRegion_[iRow];
	if (CoinAbs(newValue)>maximumRHSChange) {
	  maximumRHSChange=CoinAbs(newValue);
	} 
	CoinWorkDouble result=newValue+oldValue;
	newError[iRow]=result;
	//newError[iRow]=0.0;
	//assert(deltaY_[iRow]==0.0);
	deltaY_[iRow]=0.0;
      } 
    } 
    relativeError = maximumRHSError/solutionNorm_;
    relativeError = maximumRHSError/saveMaximum;
    if (relativeError>tryError) 
      relativeError=tryError;
    if (numberTries==1)
      firstError=relativeError;
    if (relativeError<lastError) {
      lastError2=relativeError;
      maximumRHSChange_= maximumRHSChange;
      if (relativeError>projectionTolerance&&numberTries<=3) {
        //try and refine
        goodSolve=false;
      } 
      //*** extra test here
      if (!goodSolve) {
        if (!regionSave) {
          regionSave = new CoinWorkDouble [numberRows_];
	  if (cholesky_->type()>=20) 
	    region1Save = new CoinWorkDouble [numberTotal];
        } 
        CoinMemcpyN(deltaY_,numberRows_,regionSave);
	if (cholesky_->type()<20) {
	  // not KKT
	  multiplyAdd(newError,numberRows_,-1.0,deltaY_,0.0);
	} else {
	  // KKT
	  CoinMemcpyN(deltaX_,numberTotal,region1Save);
	  // and back to input region
	  CoinMemcpyN(deltaY_,numberRows_,newError);
	}
      } 
    } else {
      //std::cout <<" worse residual = "<<relativeError;
      //bring back previous
      relativeError=lastError;
      if (regionSave) {
	CoinMemcpyN(regionSave,numberRows_,deltaY_);
	if (cholesky_->type()<20) {
	  // not KKT
	  multiplyAdd(deltaY_,numberRows_,-1.0,deltaX_+numberColumns_,0.0);
	  CoinZeroN(deltaX_,numberColumns_);
	  matrix_->transposeTimes(1.0,deltaY_,deltaX_);
	  //if flagged then entries zero so can do
	  for (iColumn=0;iColumn<numberTotal;iColumn++)
	    deltaX_[iColumn] = deltaX_[iColumn]*diagonal_[iColumn]
	      -workArray_[iColumn];
	} else {
	  // KKT
	  CoinMemcpyN(region1Save,numberTotal,deltaX_);
	}
      } else {
	// disaster
	CoinFillN(deltaX_,numberTotal,static_cast<CoinWorkDouble>(1.0));
	CoinFillN(deltaY_,numberRows_,static_cast<CoinWorkDouble>(1.0));
	printf("bad cholesky\n");
      }
    }
  } /* endwhile */
  if (firstError>1.0e-8||numberTries>1) {
    handler_->message(CLP_BARRIER_ACCURACY,messages_)
      <<phase<<numberTries<<static_cast<double>(firstError)
      <<static_cast<double>(lastError2)
      <<CoinMessageEol;
  } 
  delete [] regionSave;
  delete [] region1Save;
  delete [] newError;
  // now rest
  CoinWorkDouble extra=eExtra;
  //multiplyAdd(deltaY_,numberRows_,1.0,deltaW_+numberColumns_,0.0);
  //CoinZeroN(deltaW_,numberColumns_);
  //matrix_->transposeTimes(-1.0,deltaY_,deltaW_);
  
  for (iColumn=0;iColumn<numberRows_+numberColumns_;iColumn++) {
    deltaSU_[iColumn]=0.0;
    deltaSL_[iColumn]=0.0;
    deltaZ_[iColumn]=0.0;
    CoinWorkDouble dd=deltaW_[iColumn];
    deltaW_[iColumn]=0.0;
    if (!flagged(iColumn)) {
      CoinWorkDouble deltaX = deltaX_[iColumn];
      if (lowerBound(iColumn)) {
	CoinWorkDouble zValue = rhsZ_[iColumn];
	CoinWorkDouble gHat = zValue + zVec_[iColumn]*rhsL_[iColumn];
	CoinWorkDouble slack = lowerSlack_[iColumn]+extra;
	deltaSL_[iColumn] = -rhsL_[iColumn]+deltaX;
	deltaZ_[iColumn]=(gHat-zVec_[iColumn]*deltaX)/slack;
      } 
      if (upperBound(iColumn)) {
	CoinWorkDouble wValue = rhsW_[iColumn];
	CoinWorkDouble hHat = wValue - wVec_[iColumn]*rhsU_[iColumn];
	CoinWorkDouble slack = upperSlack_[iColumn]+extra;
	deltaSU_[iColumn] = rhsU_[iColumn]-deltaX;
	deltaW_[iColumn]=(hHat+wVec_[iColumn]*deltaX)/slack;
      }
      if (0) {
	// different way of calculating
	CoinWorkDouble gamma2 = gamma_*gamma_;
	CoinWorkDouble dZ=0.0;
	CoinWorkDouble dW=0.0;
	CoinWorkDouble zValue = rhsZ_[iColumn];
	CoinWorkDouble gHat = zValue + zVec_[iColumn]*rhsL_[iColumn];
	CoinWorkDouble slackL = lowerSlack_[iColumn]+extra;
	CoinWorkDouble wValue = rhsW_[iColumn];
	CoinWorkDouble hHat = wValue - wVec_[iColumn]*rhsU_[iColumn];
	CoinWorkDouble slackU = upperSlack_[iColumn]+extra;
	CoinWorkDouble q = rhsC_[iColumn]+gamma2 * deltaX +dd;
	if (primalR_)
	  q += deltaX*primalR_[iColumn];
	dW = (gHat+hHat -slackL*q + (wValue-zValue)*deltaX)/(slackL+slackU);
	dZ = dW + q;
	//printf("B %d old %g %g new %g %g\n",iColumn,deltaZ_[iColumn],
	//deltaW_[iColumn],dZ,dW);
	if (lowerBound(iColumn)) {
	  if (upperBound(iColumn)) {
	    //printf("B %d old %g %g new %g %g\n",iColumn,deltaZ_[iColumn],
	    //deltaW_[iColumn],dZ,dW);
	    deltaW_[iColumn]=dW;
	    deltaZ_[iColumn]=dZ;
	  } else {
	    // just lower
	    //printf("L %d old %g new %g\n",iColumn,deltaZ_[iColumn],
	    //dZ);
	  }
	} else {
	  assert (upperBound(iColumn));
	  //printf("U %d old %g new %g\n",iColumn,deltaW_[iColumn],
	  //dW);
	}
      }
    }
  }
#if 0
  CoinWorkDouble * check = new CoinWorkDouble[numberTotal];  
  // Check out rhsC_
  multiplyAdd(deltaY_,numberRows_,-1.0,check+numberColumns_,0.0);
  CoinZeroN(check,numberColumns_);
  matrix_->transposeTimes(1.0,deltaY_,check);
  quadraticDjs(check,deltaX_,-1.0);
  for (iColumn=0;iColumn<numberTotal;iColumn++) {
    check[iColumn] += deltaZ_[iColumn]-deltaW_[iColumn];
    if (CoinAbs(check[iColumn]-rhsC_[iColumn])>1.0e-3)
      printf("rhsC %d %g %g\n",iColumn,check[iColumn],rhsC_[iColumn]);
  }
  // Check out rhsZ_
  for (iColumn=0;iColumn<numberTotal;iColumn++) {
    check[iColumn] += lowerSlack_[iColumn]*deltaZ_[iColumn]+
      zVec_[iColumn]*deltaSL_[iColumn];
    if (CoinAbs(check[iColumn]-rhsZ_[iColumn])>1.0e-3)
      printf("rhsZ %d %g %g\n",iColumn,check[iColumn],rhsZ_[iColumn]);
  }
  // Check out rhsW_
  for (iColumn=0;iColumn<numberTotal;iColumn++) {
    check[iColumn] += upperSlack_[iColumn]*deltaW_[iColumn]+
      wVec_[iColumn]*deltaSU_[iColumn];
    if (CoinAbs(check[iColumn]-rhsW_[iColumn])>1.0e-3)
      printf("rhsW %d %g %g\n",iColumn,check[iColumn],rhsW_[iColumn]);
  }
  delete [] check;
#endif
  return relativeError;
}
// createSolution.  Creates solution from scratch
int ClpPredictorCorrector::createSolution()
{
  int numberTotal = numberRows_+numberColumns_;
  int iColumn;
  CoinWorkDouble tolerance = primalTolerance();
  // See if quadratic objective
#ifndef NO_RTTI
  ClpQuadraticObjective * quadraticObj = (dynamic_cast< ClpQuadraticObjective*>(objective_));
#else
  ClpQuadraticObjective * quadraticObj = NULL;
  if (objective_->type()==2)
    quadraticObj = (static_cast< ClpQuadraticObjective*>(objective_));
#endif
  if (!quadraticObj) {
    for (iColumn=0;iColumn<numberTotal;iColumn++) {
      if (upper_[iColumn]-lower_[iColumn]>tolerance) 
	clearFixed(iColumn);
      else
	setFixed(iColumn);
    }
  } else {
    // try leaving fixed
    for (iColumn=0;iColumn<numberTotal;iColumn++) 
      clearFixed(iColumn);
  }

  CoinWorkDouble maximumObjective=0.0;
  CoinWorkDouble objectiveNorm2=0.0;
  getNorms(cost_,numberTotal,maximumObjective,objectiveNorm2);
  if (!maximumObjective) {
    maximumObjective=1.0; // objective all zero
  } 
  objectiveNorm2=CoinSqrt(objectiveNorm2)/static_cast<CoinWorkDouble> (numberTotal);
  objectiveNorm_=maximumObjective;
  scaleFactor_=1.0;
  if (maximumObjective>0.0) {
    if (maximumObjective<1.0) {
      scaleFactor_=maximumObjective;
    } else if (maximumObjective>1.0e4) {
      scaleFactor_=maximumObjective/1.0e4;
    } 
  } 
  if (scaleFactor_!=1.0) {
    objectiveNorm2*=scaleFactor_;
    multiplyAdd(NULL,numberTotal,0.0,cost_,1.0/scaleFactor_);
    objectiveNorm_=maximumObjective/scaleFactor_;
  }
  // See if quadratic objective
  if (quadraticObj) {
    // If scaled then really scale matrix
    CoinWorkDouble scaleFactor = 
      scaleFactor_*optimizationDirection_*objectiveScale_*
      rhsScale_;
    if ((scalingFlag_>0&&rowScale_)||scaleFactor != 1.0) {
      CoinPackedMatrix * quadratic = quadraticObj->quadraticObjective();
      const int * columnQuadratic = quadratic->getIndices();
      const CoinBigIndex * columnQuadraticStart = quadratic->getVectorStarts();
      const int * columnQuadraticLength = quadratic->getVectorLengths();
      double * quadraticElement = quadratic->getMutableElements();
      int numberColumns = quadratic->getNumCols();
      CoinWorkDouble scale = 1.0/scaleFactor;
      if (scalingFlag_>0&&rowScale_) {
	for (int iColumn=0;iColumn<numberColumns;iColumn++) {
	  CoinWorkDouble scaleI = columnScale_[iColumn]*scale;
	  for (CoinBigIndex j=columnQuadraticStart[iColumn];
	       j<columnQuadraticStart[iColumn]+columnQuadraticLength[iColumn];j++) {
	    int jColumn = columnQuadratic[j];
	    CoinWorkDouble scaleJ = columnScale_[jColumn];
	    quadraticElement[j] *= scaleI*scaleJ;
	    objectiveNorm_ = CoinMax(objectiveNorm_,CoinAbs(quadraticElement[j]));
	  }
	}
      } else {
	// not scaled
	for (int iColumn=0;iColumn<numberColumns;iColumn++) {
	  for (CoinBigIndex j=columnQuadraticStart[iColumn];
	       j<columnQuadraticStart[iColumn]+columnQuadraticLength[iColumn];j++) {
	    quadraticElement[j] *= scale;
	    objectiveNorm_ = CoinMax(objectiveNorm_,CoinAbs(quadraticElement[j]));
	  }
	}
      }
    }
  }
  baseObjectiveNorm_=objectiveNorm_;
  //accumulate fixed in dj region (as spare)
  //accumulate primal solution in primal region
  //DZ in lowerDual
  //DW in upperDual
  CoinWorkDouble infiniteCheck=1.0e40;
  //CoinWorkDouble     fakeCheck=1.0e10;
  //use deltaX region for work region
  for (iColumn=0;iColumn<numberTotal;iColumn++) {
    CoinWorkDouble primalValue = solution_[iColumn];
    clearFlagged(iColumn);
    clearFixedOrFree(iColumn);
    clearLowerBound(iColumn);
    clearUpperBound(iColumn);
    clearFakeLower(iColumn);
    clearFakeUpper(iColumn);
    if (!fixed(iColumn)) {
      dj_[iColumn]=0.0;
      diagonal_[iColumn]=1.0;
      deltaX_[iColumn]=1.0;
      CoinWorkDouble lowerValue=lower_[iColumn];
      CoinWorkDouble upperValue=upper_[iColumn];
      if (lowerValue>-infiniteCheck) {
        if (upperValue<infiniteCheck) {
          //upper and lower bounds
          setLowerBound(iColumn);
          setUpperBound(iColumn);
          if (lowerValue>=0.0) {
            solution_[iColumn]=lowerValue;
          } else if (upperValue<=0.0) {
            solution_[iColumn]=upperValue;
          } else {
            solution_[iColumn]=0.0;
          } 
        } else {
          //just lower bound
          setLowerBound(iColumn);
          if (lowerValue>=0.0) {
            solution_[iColumn]=lowerValue;
          } else {
            solution_[iColumn]=0.0;
          } 
        } 
      } else {
        if (upperValue<infiniteCheck) {
          //just upper bound
          setUpperBound(iColumn);
          if (upperValue<=0.0) {
            solution_[iColumn]=upperValue;
          } else {
            solution_[iColumn]=0.0;
          } 
        } else {
          //free
          setFixedOrFree(iColumn);
          solution_[iColumn]=0.0;
          //std::cout<<" free "<<i<<std::endl;
        } 
      } 
    } else {
      setFlagged(iColumn);
      setFixedOrFree(iColumn);
      setLowerBound(iColumn);
      setUpperBound(iColumn);
      dj_[iColumn]=primalValue;;
      solution_[iColumn]=lower_[iColumn];
      diagonal_[iColumn]=0.0;
      deltaX_[iColumn]=0.0;
    } 
  } 
  //   modify fixed RHS
  multiplyAdd(dj_+numberColumns_,numberRows_,-1.0,rhsFixRegion_,0.0);
  //   create plausible RHS?
  matrix_->times(-1.0,dj_,rhsFixRegion_);
  multiplyAdd(solution_+numberColumns_,numberRows_,1.0,errorRegion_,0.0);
  matrix_->times(-1.0,solution_,errorRegion_);
  rhsNorm_=maximumAbsElement(errorRegion_,numberRows_);
  if (rhsNorm_<1.0) {
    rhsNorm_=1.0;
  } 
  int * rowsDropped = new int [numberRows_];
  int returnCode=cholesky_->factorize(diagonal_,rowsDropped);
  if (returnCode==-1) {
    printf("Out of memory\n");
    problemStatus_=4;
    return -1;
  }
  if (cholesky_->status()) {
    std::cout << "singular on initial cholesky?" <<std::endl;
    cholesky_->resetRowsDropped();
    //cholesky_->factorize(rowDropped_);
    //if (cholesky_->status()) {
      //std::cout << "bad cholesky??? (after retry)" <<std::endl;
      //abort();
    //} 
  } 
  delete [] rowsDropped;
  if (cholesky_->type()<20) {
    // not KKT
    cholesky_->solve(errorRegion_);
    //create information for solution
    multiplyAdd(errorRegion_,numberRows_,-1.0,deltaX_+numberColumns_,0.0);
    CoinZeroN(deltaX_,numberColumns_);
    matrix_->transposeTimes(1.0,errorRegion_,deltaX_);
  } else {
    // KKT
    // reverse sign on solution
    multiplyAdd(NULL,numberRows_+numberColumns_,0.0,solution_,-1.0);
    solveSystem(deltaX_,errorRegion_,solution_,NULL,NULL,NULL,false);
  }
  CoinWorkDouble initialValue = 1.0e2;
  if (rhsNorm_*1.0e-2>initialValue) {
    initialValue=rhsNorm_*1.0e-2;
  } 
  //initialValue = CoinMax(1.0,rhsNorm_);
  CoinWorkDouble smallestBoundDifference=COIN_DBL_MAX;
  CoinWorkDouble * fakeSolution = deltaX_;
  for ( iColumn=0;iColumn<numberTotal;iColumn++) {
    if (!flagged(iColumn)) {
      if (lower_[iColumn]-fakeSolution[iColumn]>initialValue) {
        initialValue=lower_[iColumn]-fakeSolution[iColumn];
      } 
      if (fakeSolution[iColumn]-upper_[iColumn]>initialValue) {
        initialValue=fakeSolution[iColumn]-upper_[iColumn];
      } 
      if (upper_[iColumn]-lower_[iColumn]<smallestBoundDifference) {
        smallestBoundDifference=upper_[iColumn]-lower_[iColumn];
      } 
    } 
  } 
  solutionNorm_=1.0e-12;
  handler_->message(CLP_BARRIER_SAFE,messages_)
    <<static_cast<double>(initialValue)<<static_cast<double>(objectiveNorm_)
    <<CoinMessageEol;
  CoinWorkDouble extra=1.0e-10;
  CoinWorkDouble largeGap=1.0e15;
  //CoinWorkDouble safeObjectiveValue=2.0*objectiveNorm_;
  CoinWorkDouble safeObjectiveValue=objectiveNorm_+1.0;
  CoinWorkDouble safeFree=1.0e-1*initialValue;
  //printf("normal safe dual value of %g, primal value of %g\n",
  // safeObjectiveValue,initialValue);
  //safeObjectiveValue=CoinMax(2.0,1.0e-1*safeObjectiveValue);
  //initialValue=CoinMax(100.0,1.0e-1*initialValue);;
  //printf("temp safe dual value of %g, primal value of %g\n",
  // safeObjectiveValue,initialValue);
  CoinWorkDouble zwLarge=1.0e2*initialValue;
  //zwLarge=1.0e40;
  if (cholesky_->choleskyCondition()<0.0&&cholesky_->type()<20) {
    // looks bad - play safe
    initialValue *=10.0;
    safeObjectiveValue *= 10.0;
    safeFree *= 10.0;
  }
  CoinWorkDouble gamma2 = gamma_*gamma_; // gamma*gamma will be added to diagonal
  // First do primal side
  for ( iColumn=0;iColumn<numberTotal;iColumn++) {
    if (!flagged(iColumn)) {
      CoinWorkDouble lowerValue=lower_[iColumn];
      CoinWorkDouble upperValue=upper_[iColumn];
      CoinWorkDouble newValue;
      CoinWorkDouble setPrimal=initialValue;
      if (quadraticObj) {
	// perturb primal solution a bit
	//fakeSolution[iColumn]  *= 0.002*CoinDrand48()+0.999;
      }
      if (lowerBound(iColumn)) {
        if (upperBound(iColumn)) {
          //upper and lower bounds
          if (upperValue-lowerValue>2.0*setPrimal) {
            CoinWorkDouble fakeValue=fakeSolution[iColumn];
            if (fakeValue<lowerValue+setPrimal) {
              fakeValue=lowerValue+setPrimal;
            } 
            if (fakeValue>upperValue-setPrimal) {
              fakeValue=upperValue-setPrimal;
            } 
            newValue=fakeValue;
          } else {
            newValue=0.5*(upperValue+lowerValue);
          }
        } else {
          //just lower bound
          CoinWorkDouble fakeValue=fakeSolution[iColumn];
          if (fakeValue<lowerValue+setPrimal) {
            fakeValue=lowerValue+setPrimal;
          } 
          newValue=fakeValue;
        } 
      } else {
        if (upperBound(iColumn)) {
          //just upper bound
          CoinWorkDouble fakeValue=fakeSolution[iColumn];
          if (fakeValue>upperValue-setPrimal) {
            fakeValue=upperValue-setPrimal;
          } 
          newValue=fakeValue;
        } else {
          //free
          newValue=fakeSolution[iColumn];
          if (newValue>=0.0) {
            if (newValue<safeFree) {
              newValue=safeFree;
            } 
          } else {
            if (newValue>-safeFree) {
              newValue=-safeFree;
            } 
          } 
        } 
      } 
      solution_[iColumn]=newValue;
    } else {
      // fixed
      lowerSlack_[iColumn]=0.0;
      upperSlack_[iColumn]=0.0;
      solution_[iColumn]=lower_[iColumn];
      zVec_[iColumn]=0.0;
      wVec_[iColumn]=0.0;
      diagonal_[iColumn]=0.0;
    } 
  }
  solutionNorm_ =  maximumAbsElement(solution_,numberTotal);
  // Set bounds and do dj including quadratic
  largeGap = CoinMax(1.0e7,1.02*solutionNorm_);
  CoinPackedMatrix * quadratic = NULL;
  const int * columnQuadratic = NULL;
  const CoinBigIndex * columnQuadraticStart = NULL;
  const int * columnQuadraticLength = NULL;
  const double * quadraticElement = NULL;
  if (quadraticObj) {
    quadratic = quadraticObj->quadraticObjective();
    columnQuadratic = quadratic->getIndices();
    columnQuadraticStart = quadratic->getVectorStarts();
    columnQuadraticLength = quadratic->getVectorLengths();
    quadraticElement = quadratic->getElements();
  }
  CoinWorkDouble quadraticNorm=0.0;
  for ( iColumn=0;iColumn<numberTotal;iColumn++) {
    if (!flagged(iColumn)) {
      CoinWorkDouble primalValue=solution_[iColumn];
      CoinWorkDouble lowerValue=lower_[iColumn];
      CoinWorkDouble upperValue=upper_[iColumn];
      // Do dj
      CoinWorkDouble reducedCost=cost_[iColumn];
      if (lowerBound(iColumn)) {
	reducedCost+=linearPerturbation_;
      } 
      if (upperBound(iColumn)) {
	reducedCost-=linearPerturbation_;
      }
      if (quadraticObj&&iColumn<numberColumns_) {
	for (CoinBigIndex j=columnQuadraticStart[iColumn];
	     j<columnQuadraticStart[iColumn]+columnQuadraticLength[iColumn];j++) {
	  int jColumn = columnQuadratic[j];
	  CoinWorkDouble valueJ = solution_[jColumn];
	  CoinWorkDouble elementValue = quadraticElement[j];
	  reducedCost += valueJ*elementValue;
	}
	quadraticNorm = CoinMax(quadraticNorm,CoinAbs(reducedCost));
      }
      dj_[iColumn]=reducedCost;
      if (primalValue>lowerValue+largeGap&&primalValue<upperValue-largeGap) {
	clearFixedOrFree(iColumn);
	setLowerBound(iColumn);
	setUpperBound(iColumn);
	lowerValue=CoinMax(lowerValue,primalValue-largeGap);
	upperValue=CoinMin(upperValue,primalValue+largeGap);
	lower_[iColumn]=lowerValue;
	upper_[iColumn]=upperValue;
      }
    }
  }
  safeObjectiveValue=CoinMax(safeObjectiveValue,quadraticNorm);
  for ( iColumn=0;iColumn<numberTotal;iColumn++) {
    if (!flagged(iColumn)) {
      CoinWorkDouble primalValue=solution_[iColumn];
      CoinWorkDouble lowerValue=lower_[iColumn];
      CoinWorkDouble upperValue=upper_[iColumn];
      CoinWorkDouble reducedCost=dj_[iColumn];
      CoinWorkDouble low=0.0;
      CoinWorkDouble high=0.0;
      if (lowerBound(iColumn)) {
        if (upperBound(iColumn)) {
          //upper and lower bounds
          if (upperValue-lowerValue>2.0*initialValue) {
            low=primalValue-lowerValue;
            high=upperValue-primalValue;
          } else {
            low=initialValue;
            high=initialValue;
          }
          CoinWorkDouble s = low+extra;
          CoinWorkDouble ratioZ;
          if (s<zwLarge) {
            ratioZ=1.0;
          } else {
            ratioZ=CoinSqrt(zwLarge/s);
          } 
          CoinWorkDouble t = high+extra;
          CoinWorkDouble ratioT;
          if (t<zwLarge) {
            ratioT=1.0;
          } else {
            ratioT=CoinSqrt(zwLarge/t);
          } 
          //modify s and t
          if (s>largeGap) {
            s=largeGap;
          } 
          if (t>largeGap) {
            t=largeGap;
          } 
          //modify if long long way away from bound
          if (reducedCost>=0.0) {
            zVec_[iColumn]=reducedCost + safeObjectiveValue*ratioZ;
            zVec_[iColumn]=CoinMax(reducedCost, safeObjectiveValue*ratioZ);
            wVec_[iColumn]=safeObjectiveValue*ratioT;
          } else {
            zVec_[iColumn]=safeObjectiveValue*ratioZ;
            wVec_[iColumn]=-reducedCost + safeObjectiveValue*ratioT;
            wVec_[iColumn]=CoinMax(-reducedCost , safeObjectiveValue*ratioT);
          }
	  CoinWorkDouble gammaTerm = gamma2;
	  if (primalR_)
	    gammaTerm += primalR_[iColumn];
          diagonal_[iColumn] = (t*s)/
	    (s*wVec_[iColumn]+t*zVec_[iColumn]+gammaTerm*t*s);
        } else {
          //just lower bound
          low=primalValue-lowerValue;
          high=0.0;
          CoinWorkDouble s = low+extra;
          CoinWorkDouble ratioZ;
          if (s<zwLarge) {
            ratioZ=1.0;
          } else {
            ratioZ=CoinSqrt(zwLarge/s);
          } 
          //modify s
          if (s>largeGap) {
            s=largeGap;
          } 
          if (reducedCost>=0.0) {
            zVec_[iColumn]=reducedCost + safeObjectiveValue*ratioZ;
            zVec_[iColumn]=CoinMax(reducedCost , safeObjectiveValue*ratioZ);
            wVec_[iColumn]=0.0;
          } else {
            zVec_[iColumn]=safeObjectiveValue*ratioZ;
            wVec_[iColumn]=0.0;
          } 
	  CoinWorkDouble gammaTerm = gamma2;
	  if (primalR_)
	    gammaTerm += primalR_[iColumn];
          diagonal_[iColumn] = s/(zVec_[iColumn]+s*gammaTerm);
        } 
      } else {
        if (upperBound(iColumn)) {
          //just upper bound
          low=0.0;
          high=upperValue-primalValue;
          CoinWorkDouble t = high+extra;
          CoinWorkDouble ratioT;
          if (t<zwLarge) {
            ratioT=1.0;
          } else {
            ratioT=CoinSqrt(zwLarge/t);
          } 
          //modify t
          if (t>largeGap) {
            t=largeGap;
          } 
          if (reducedCost>=0.0) {
            zVec_[iColumn]=0.0;
            wVec_[iColumn]=safeObjectiveValue*ratioT;
          } else {
            zVec_[iColumn]=0.0;
            wVec_[iColumn]=-reducedCost + safeObjectiveValue*ratioT;
            wVec_[iColumn]=CoinMax(-reducedCost , safeObjectiveValue*ratioT);
          } 
	  CoinWorkDouble gammaTerm = gamma2;
	  if (primalR_)
	    gammaTerm += primalR_[iColumn];
          diagonal_[iColumn] =  t/(wVec_[iColumn]+t*gammaTerm);
        } 
      } 
      lowerSlack_[iColumn]=low;
      upperSlack_[iColumn]=high;
    }
  }
#if 0
  if (solution_[0]>0.0) {
    for (int i=0;i<numberTotal;i++)
      printf("%d %.18g %.18g %.18g %.18g %.18g %.18g %.18g\n",i,CoinAbs(solution_[i]),
	     diagonal_[i],CoinAbs(dj_[i]),
	     lowerSlack_[i],zVec_[i],
	     upperSlack_[i],wVec_[i]);
  } else {
    for (int i=0;i<numberTotal;i++)
      printf("%d %.18g %.18g %.18g %.18g %.18g %.18g %.18g\n",i,CoinAbs(solution_[i]),
	     diagonal_[i],CoinAbs(dj_[i]),
	     upperSlack_[i],wVec_[i],
	     lowerSlack_[i],zVec_[i] );
  }
  exit(66);
#endif
  return 0;
}
// complementarityGap.  Computes gap
//phase 0=as is , 1 = after predictor , 2 after corrector
CoinWorkDouble ClpPredictorCorrector::complementarityGap(int & numberComplementarityPairs,
						 int & numberComplementarityItems,
						 const int phase)
{
  CoinWorkDouble gap=0.0;
  //seems to be same coding for phase = 1 or 2
  numberComplementarityPairs=0;
  numberComplementarityItems=0;
  int numberTotal = numberRows_+numberColumns_;
  CoinWorkDouble toleranceGap=0.0;
  CoinWorkDouble largestGap=0.0;
  CoinWorkDouble smallestGap=COIN_DBL_MAX;
  //seems to be same coding for phase = 1 or 2
  int numberNegativeGaps=0;
  CoinWorkDouble sumNegativeGap=0.0;
  CoinWorkDouble largeGap=1.0e2*solutionNorm_;
  if (largeGap<1.0e10) {
    largeGap=1.0e10;
  } 
  largeGap=1.0e30;
  CoinWorkDouble dualTolerance =  dblParam_[ClpDualTolerance];
  CoinWorkDouble primalTolerance =  dblParam_[ClpPrimalTolerance];
  dualTolerance=dualTolerance/scaleFactor_;
  for (int iColumn=0;iColumn<numberTotal;iColumn++) {
    if (!fixedOrFree(iColumn)) {
      numberComplementarityPairs++;
      //can collapse as if no lower bound both zVec and deltaZ 0.0
      CoinWorkDouble newZ=0.0;
      CoinWorkDouble newW=0.0;
      if (lowerBound(iColumn)) {
	numberComplementarityItems++;
        CoinWorkDouble dualValue;
        CoinWorkDouble primalValue;
        if (!phase) {
          dualValue=zVec_[iColumn];
          primalValue=lowerSlack_[iColumn];
        } else {
          CoinWorkDouble change;
	  change =solution_[iColumn]+deltaX_[iColumn]-lowerSlack_[iColumn]-lower_[iColumn];
          dualValue=zVec_[iColumn]+actualDualStep_*deltaZ_[iColumn];
	  newZ=dualValue;
          primalValue=lowerSlack_[iColumn]+actualPrimalStep_*change;
        }
        //reduce primalValue
        if (primalValue>largeGap) {
          primalValue=largeGap;
        } 
        CoinWorkDouble gapProduct=dualValue*primalValue;
        if (gapProduct<0.0) {
          //cout<<"negative gap component "<<iColumn<<" "<<dualValue<<" "<<
              //primalValue<<endl;
          numberNegativeGaps++;
          sumNegativeGap-=gapProduct;
          gapProduct=0.0;
        } 
        gap+=gapProduct;
	//printf("l %d prim %g dual %g totalGap %g\n",
	//   iColumn,primalValue,dualValue,gap);
        if (gapProduct>largestGap) {
          largestGap=gapProduct;
        }
	smallestGap = CoinMin(smallestGap,gapProduct);
        if (dualValue>dualTolerance&&primalValue>primalTolerance) {
          toleranceGap+=dualValue*primalValue;
        } 
      } 
      if (upperBound(iColumn)) {
	numberComplementarityItems++;
        CoinWorkDouble dualValue;
        CoinWorkDouble primalValue;
        if (!phase) {
          dualValue=wVec_[iColumn];
          primalValue=upperSlack_[iColumn];
        } else {
          CoinWorkDouble change;
	  change =upper_[iColumn]-solution_[iColumn]-deltaX_[iColumn]-upperSlack_[iColumn];
          dualValue=wVec_[iColumn]+actualDualStep_*deltaW_[iColumn];
	  newW=dualValue;
          primalValue=upperSlack_[iColumn]+actualPrimalStep_*change;
        } 
        //reduce primalValue
        if (primalValue>largeGap) {
          primalValue=largeGap;
        } 
        CoinWorkDouble gapProduct=dualValue*primalValue;
        if (gapProduct<0.0) {
          //cout<<"negative gap component "<<iColumn<<" "<<dualValue<<" "<<
              //primalValue<<endl;
          numberNegativeGaps++;
          sumNegativeGap-=gapProduct;
          gapProduct=0.0;
        } 
        gap+=gapProduct;
	//printf("u %d prim %g dual %g totalGap %g\n",
	//   iColumn,primalValue,dualValue,gap);
        if (gapProduct>largestGap) {
          largestGap=gapProduct;
        } 
        if (dualValue>dualTolerance&&primalValue>primalTolerance) {
          toleranceGap+=dualValue*primalValue;
        } 
      } 
    } 
  }
  //if (numberIterations_>4)
  //exit(9);
  if (!phase&&numberNegativeGaps) {
      handler_->message(CLP_BARRIER_NEGATIVE_GAPS,messages_)
	<<numberNegativeGaps<<static_cast<double>(sumNegativeGap)
    <<CoinMessageEol;
  } 
  
  //in case all free!
  if (!numberComplementarityPairs) {
    numberComplementarityPairs=1;
  } 
#ifdef SOME_DEBUG
  printf("with d,p steps %g,%g gap %g - smallest %g, largest %g, pairs %d\n",
	 actualDualStep_,actualPrimalStep_,
	 gap,smallestGap,largestGap,numberComplementarityPairs);
#endif
  return gap;
}
// setupForSolve.
//phase 0=affine , 1 = corrector , 2 = primal-dual
void ClpPredictorCorrector::setupForSolve(const int phase)
{
  CoinWorkDouble extra =eExtra;
  int numberTotal = numberRows_ + numberColumns_;
  int iColumn;
#ifdef SOME_DEBUG
  printf("phase %d in setupForSolve, mu %.18g\n",phase,mu_);
#endif
  CoinWorkDouble gamma2 = gamma_*gamma_; // gamma*gamma will be added to diagonal
  CoinWorkDouble * dualArray = reinterpret_cast<CoinWorkDouble *>(dual_);
  switch (phase) {
  case 0:
    CoinMemcpyN(errorRegion_,numberRows_,rhsB_);
    if (delta_||dualR_) {
      // add in regularization
      CoinWorkDouble delta2 = delta_*delta_;
      for (int iRow=0;iRow<numberRows_;iRow++) {
	rhsB_[iRow] -= delta2*dualArray[iRow];
	if (dualR_)
	  rhsB_[iRow] -= dualR_[iRow]*dualArray[iRow];
      }
    }
    for (iColumn=0;iColumn<numberTotal;iColumn++) {
      rhsC_[iColumn]=0.0;
      rhsU_[iColumn]=0.0;
      rhsL_[iColumn]=0.0;
      rhsZ_[iColumn]=0.0;
      rhsW_[iColumn]=0.0;
      if (!flagged(iColumn)) {
	rhsC_[iColumn] = dj_[iColumn]-zVec_[iColumn]+wVec_[iColumn];
	rhsC_[iColumn] += gamma2*solution_[iColumn];
	if (primalR_)
	  rhsC_[iColumn] += primalR_[iColumn]*solution_[iColumn];
	if (lowerBound(iColumn)) {
	  rhsZ_[iColumn] = -zVec_[iColumn]*(lowerSlack_[iColumn]+extra);
	  rhsL_[iColumn] = CoinMax(0.0,(lower_[iColumn]+lowerSlack_[iColumn])-solution_[iColumn]);
	} 
	if (upperBound(iColumn)) {
	  rhsW_[iColumn] = -wVec_[iColumn]*(upperSlack_[iColumn]+extra);
	  rhsU_[iColumn] = CoinMin(0.0,(upper_[iColumn]-upperSlack_[iColumn])-solution_[iColumn]);
	}
      }
    } 
#if 0
    for (int i=0;i<3;i++) {
      if (!CoinAbs(rhsZ_[i]))
	rhsZ_[i]=0.0;
      if (!CoinAbs(rhsW_[i]))
	rhsW_[i]=0.0;
      if (!CoinAbs(rhsU_[i]))
	rhsU_[i]=0.0;
      if (!CoinAbs(rhsL_[i]))
	rhsL_[i]=0.0;
    }
    if (solution_[0]>0.0) {
      for (int i=0;i<3;i++)
	printf("%d %.18g %.18g %.18g %.18g %.18g %.18g %.18g\n",i,solution_[i],
	       diagonal_[i],dj_[i],
	       lowerSlack_[i],zVec_[i],
	       upperSlack_[i],wVec_[i]);
      for (int i=0;i<3;i++)
	printf("%d %.18g %.18g %.18g %.18g %.18g\n",i,rhsC_[i],
	       rhsZ_[i],rhsL_[i],
	       rhsW_[i],rhsU_[i]);
    } else {
      for (int i=0;i<3;i++)
	printf("%d %.18g %.18g %.18g %.18g %.18g %.18g %.18g\n",i,solution_[i],
	       diagonal_[i],dj_[i],
	       lowerSlack_[i],zVec_[i],
	       upperSlack_[i],wVec_[i]);
      for (int i=0;i<3;i++)
	printf("%d %.18g %.18g %.18g %.18g %.18g\n",i,rhsC_[i],
	       rhsZ_[i],rhsL_[i],
	       rhsW_[i],rhsU_[i]);
    }
#endif
    break;
  case 1:
    // could be stored in delta2?
    for (iColumn=0;iColumn<numberTotal;iColumn++) {
      rhsZ_[iColumn]=0.0;
      rhsW_[iColumn]=0.0;
      if (!flagged(iColumn)) {
        if (lowerBound(iColumn)) {
	  rhsZ_[iColumn] = mu_ -zVec_[iColumn]*(lowerSlack_[iColumn]+extra)
	    - deltaZ_[iColumn]*deltaX_[iColumn];
	  // To bring in line with OSL
	  rhsZ_[iColumn] += deltaZ_[iColumn]*rhsL_[iColumn];
        } 
        if (upperBound(iColumn)) {
	  rhsW_[iColumn] = mu_ -wVec_[iColumn]*(upperSlack_[iColumn]+extra)
	    +deltaW_[iColumn]*deltaX_[iColumn];
	  // To bring in line with OSL
	  rhsW_[iColumn] -= deltaW_[iColumn]*rhsU_[iColumn];
        } 
      } 
    } 
#if 0
    for (int i=0;i<numberTotal;i++) {
      if (!CoinAbs(rhsZ_[i]))
	rhsZ_[i]=0.0;
      if (!CoinAbs(rhsW_[i]))
	rhsW_[i]=0.0;
      if (!CoinAbs(rhsU_[i]))
	rhsU_[i]=0.0;
      if (!CoinAbs(rhsL_[i]))
	rhsL_[i]=0.0;
    }
    if (solution_[0]>0.0) {
      for (int i=0;i<numberTotal;i++)
	printf("%d %.18g %.18g %.18g %.18g %.18g %.18g %.18g\n",i,CoinAbs(solution_[i]),
	       diagonal_[i],CoinAbs(dj_[i]),
	       lowerSlack_[i],zVec_[i],
	       upperSlack_[i],wVec_[i]);
      for (int i=0;i<numberTotal;i++)
	printf("%d %.18g %.18g %.18g %.18g %.18g\n",i,CoinAbs(rhsC_[i]),
	       rhsZ_[i],rhsL_[i],
	       rhsW_[i],rhsU_[i]);
    } else {
      for (int i=0;i<numberTotal;i++)
	printf("%d %.18g %.18g %.18g %.18g %.18g %.18g %.18g\n",i,CoinAbs(solution_[i]),
	       diagonal_[i],CoinAbs(dj_[i]),
	       upperSlack_[i],wVec_[i],
	       lowerSlack_[i],zVec_[i] );
      for (int i=0;i<numberTotal;i++)
	printf("%d %.18g %.18g %.18g %.18g %.18g\n",i,CoinAbs(rhsC_[i]),
	       rhsW_[i],rhsU_[i],
	       rhsZ_[i],rhsL_[i]);
    }
    exit(66);
#endif
    break;
  case 2:
    CoinMemcpyN(errorRegion_,numberRows_,rhsB_);
    for (iColumn=0;iColumn<numberTotal;iColumn++) {
      rhsZ_[iColumn]=0.0;
      rhsW_[iColumn]=0.0;
      if (!flagged(iColumn)) {
        if (lowerBound(iColumn)) {
	  rhsZ_[iColumn] = mu_ - zVec_[iColumn]*(lowerSlack_[iColumn]+extra);
        } 
        if (upperBound(iColumn)) {
	  rhsW_[iColumn] = mu_ - wVec_[iColumn]*(upperSlack_[iColumn]+extra);
        }
      }
    } 
    break;
  case 3:
    {
      CoinWorkDouble minBeta = 0.1*mu_;
      CoinWorkDouble maxBeta = 10.0*mu_;
      CoinWorkDouble dualStep = CoinMin(1.0,actualDualStep_+0.1);
      CoinWorkDouble primalStep = CoinMin(1.0,actualPrimalStep_+0.1);
#ifdef SOME_DEBUG
      printf("good complementarity range %g to %g\n",minBeta,maxBeta);
#endif
      //minBeta=0.0;
      //maxBeta=COIN_DBL_MAX;
      for (iColumn=0;iColumn<numberTotal;iColumn++) {
	if (!flagged(iColumn)) {
	  if (lowerBound(iColumn)) {
	    CoinWorkDouble change = -rhsL_[iColumn] + deltaX_[iColumn];
	    CoinWorkDouble dualValue=zVec_[iColumn]+dualStep*deltaZ_[iColumn];
	    CoinWorkDouble primalValue=lowerSlack_[iColumn]+primalStep*change;
	    CoinWorkDouble gapProduct=dualValue*primalValue;
	    if (gapProduct>0.0&&dualValue<0.0)
	      gapProduct = - gapProduct;
#ifdef FULL_DEBUG
	    delta2Z_[iColumn]=gapProduct;
	    if (delta2Z_[iColumn]<minBeta||delta2Z_[iColumn]>maxBeta)
	      printf("lower %d primal %g, dual %g, gap %g\n",
		     iColumn,primalValue,dualValue,gapProduct);
#endif
	    CoinWorkDouble value= 0.0;
	    if (gapProduct<minBeta) {
	      value= 2.0*(minBeta-gapProduct);
	      value= (mu_-gapProduct);
	      value= (minBeta-gapProduct);
	      assert (value>0.0);
	    } else if (gapProduct>maxBeta) {
	      value= CoinMax(maxBeta-gapProduct,-maxBeta);
	      assert (value<0.0);
	    }
	    rhsZ_[iColumn] += value;
	  }  
	  if (upperBound(iColumn)) {
	    CoinWorkDouble change = rhsU_[iColumn]-deltaX_[iColumn];
	    CoinWorkDouble dualValue=wVec_[iColumn]+dualStep*deltaW_[iColumn];
	    CoinWorkDouble primalValue=upperSlack_[iColumn]+primalStep*change;
	    CoinWorkDouble gapProduct=dualValue*primalValue;
	    if (gapProduct>0.0&&dualValue<0.0)
	      gapProduct = - gapProduct;
#ifdef FULL_DEBUG
	    delta2W_[iColumn]=gapProduct;
	    if (delta2W_[iColumn]<minBeta||delta2W_[iColumn]>maxBeta)
	      printf("upper %d primal %g, dual %g, gap %g\n",
		     iColumn,primalValue,dualValue,gapProduct);
#endif
	    CoinWorkDouble value= 0.0;
	    if (gapProduct<minBeta) {
	      value= (minBeta-gapProduct);
	      assert (value>0.0);
	    } else if (gapProduct>maxBeta) {
	      value= CoinMax(maxBeta-gapProduct,-maxBeta);
	      assert (value<0.0);
	    }
	    rhsW_[iColumn] += value;
	  } 
	} 
      }
    }
    break;
  } /* endswitch */
  if (cholesky_->type()<20) {
    for (iColumn=0;iColumn<numberTotal;iColumn++) {
      CoinWorkDouble value = rhsC_[iColumn];
      CoinWorkDouble zValue = rhsZ_[iColumn];
      CoinWorkDouble wValue = rhsW_[iColumn];
#if 0
#if 1
      if (phase==0) {
	// more accurate
	value = dj[iColumn];
	zValue=0.0;
	wValue=0.0;
      } else if (phase==2) {
	// more accurate
	value = dj[iColumn];
	zValue=mu_;
	wValue=mu_;
      }
#endif
      assert (rhsL_[iColumn]>=0.0);
      assert (rhsU_[iColumn]<=0.0);
      if (lowerBound(iColumn)) {
	value += (-zVec_[iColumn]*rhsL_[iColumn]-zValue)/
	  (lowerSlack_[iColumn]+extra);
      }
      if (upperBound(iColumn)) {
	value += (wValue-wVec_[iColumn]*rhsU_[iColumn])/
	  (upperSlack_[iColumn]+extra);
      }
#else
      if (lowerBound(iColumn)) {
	CoinWorkDouble gHat = zValue + zVec_[iColumn]*rhsL_[iColumn];
	value -= gHat/(lowerSlack_[iColumn]+extra);
      }
      if (upperBound(iColumn)) {
	CoinWorkDouble hHat = wValue - wVec_[iColumn]*rhsU_[iColumn];
	value += hHat/(upperSlack_[iColumn]+extra);
      }
#endif
      workArray_[iColumn]=diagonal_[iColumn]*value;
    } 
#if 0
    if (solution_[0]>0.0) {
      for (int i=0;i<numberTotal;i++)
	printf("%d %.18g\n",i,workArray_[i]);
    } else {
      for (int i=0;i<numberTotal;i++)
	printf("%d %.18g\n",i,workArray_[i]);
    }
    exit(66);
#endif
  } else {
    // KKT
    for (iColumn=0;iColumn<numberTotal;iColumn++) {
      CoinWorkDouble value = rhsC_[iColumn];
      CoinWorkDouble zValue = rhsZ_[iColumn];
      CoinWorkDouble wValue = rhsW_[iColumn];
      if (lowerBound(iColumn)) {
	CoinWorkDouble gHat = zValue + zVec_[iColumn]*rhsL_[iColumn];
	value -= gHat/(lowerSlack_[iColumn]+extra);
      }
      if (upperBound(iColumn)) {
	CoinWorkDouble hHat = wValue - wVec_[iColumn]*rhsU_[iColumn];
	value += hHat/(upperSlack_[iColumn]+extra);
      }
      workArray_[iColumn]=value;
    }
  }
}
//method: sees if looks plausible change in complementarity
bool ClpPredictorCorrector::checkGoodMove(const bool doCorrector,
					  CoinWorkDouble & bestNextGap,
					  bool allowIncreasingGap)
{
  const CoinWorkDouble beta3 = 0.99997;
  bool goodMove=false;
  int nextNumber;
  int nextNumberItems;
  int numberTotal = numberRows_+numberColumns_;
  CoinWorkDouble returnGap=bestNextGap;
  CoinWorkDouble nextGap=complementarityGap(nextNumber,nextNumberItems,2);
#ifndef NO_RTTI
  ClpQuadraticObjective * quadraticObj = (dynamic_cast< ClpQuadraticObjective*>(objective_));
#else
  ClpQuadraticObjective * quadraticObj = NULL;
  if (objective_->type()==2)
    quadraticObj = (static_cast< ClpQuadraticObjective*>(objective_));
#endif
  if (nextGap>bestNextGap&&nextGap>0.9*complementarityGap_&&doCorrector
      &&!quadraticObj&&!allowIncreasingGap) {
#ifdef SOME_DEBUG
    printf("checkGood phase 1 next gap %.18g, phase 0 %.18g, old gap %.18g\n",
	   nextGap,bestNextGap,complementarityGap_);
#endif
    return false;
  } else {
    returnGap=nextGap;
  }
  CoinWorkDouble step;
  if (actualDualStep_>actualPrimalStep_) {
    step=actualDualStep_;
  } else {
    step=actualPrimalStep_;
  } 
  CoinWorkDouble testValue=1.0-step*(1.0-beta3);
  //testValue=0.0;
  testValue*=complementarityGap_;
  if (nextGap<testValue) {
    //std::cout <<"predicted duality gap "<<nextGap<<std::endl;
    goodMove=true;
  } else if(doCorrector) {
    //if (actualDualStep_<actualPrimalStep_) {
      //step=actualDualStep_;
    //} else {
      //step=actualPrimalStep_;
    //} 
    CoinWorkDouble gap = bestNextGap;
    goodMove=checkGoodMove2(step,gap,allowIncreasingGap);
    if (goodMove)
      returnGap=gap;
  } else {
    goodMove=true;
  } 
  if (goodMove)
    goodMove=checkGoodMove2(step,bestNextGap,allowIncreasingGap);
  // Say good if small
  //if (quadraticObj) {
  if (CoinMax(actualDualStep_,actualPrimalStep_)<1.0e-6)
    goodMove=true;
  if (!goodMove) {
    //try smaller of two
    if (actualDualStep_<actualPrimalStep_) {
      step=actualDualStep_;
    } else {
      step=actualPrimalStep_;
    } 
    if (step>1.0) {
      step=1.0;
    } 
    actualPrimalStep_=step;
    //if (quadraticObj)
    //actualPrimalStep_ *=0.5;
    actualDualStep_=step;
    goodMove=checkGoodMove2(step,bestNextGap,allowIncreasingGap);
    int pass=0;
    while (!goodMove) {
      pass++;
      CoinWorkDouble gap = bestNextGap;
      goodMove=checkGoodMove2(step,gap,allowIncreasingGap);
      if (goodMove||pass>3) {
	returnGap=gap;
	break;
      }
      if (step<1.0e-4) {
        break;
      } 
      step*=0.5;
      actualPrimalStep_=step;
      //if (quadraticObj)
      //actualPrimalStep_ *=0.5;
      actualDualStep_=step;
    } /* endwhile */
    if (doCorrector) {
      //say bad move if both small
      if (numberIterations_&1) {
        if (actualPrimalStep_<1.0e-2&&actualDualStep_<1.0e-2) {
          goodMove=false;
        } 
      } else {
        if (actualPrimalStep_<1.0e-5&&actualDualStep_<1.0e-5) {
          goodMove=false;
        } 
        if (actualPrimalStep_*actualDualStep_<1.0e-20) {
          goodMove=false;
        } 
      } 
    } 
  } 
  if (goodMove) {
    //compute delta in objectives
    CoinWorkDouble deltaObjectivePrimal=0.0;
    CoinWorkDouble deltaObjectiveDual=
      innerProduct(deltaY_,numberRows_,
		   rhsFixRegion_);
    CoinWorkDouble error=0.0;
    CoinWorkDouble * workArray = workArray_;
    CoinZeroN(workArray,numberColumns_);
    CoinMemcpyN(deltaY_,numberRows_,workArray+numberColumns_);
    matrix_->transposeTimes(-1.0,deltaY_,workArray);
    //CoinWorkDouble sumPerturbCost=0.0;
    for (int iColumn=0;iColumn<numberTotal;iColumn++) {
      if (!flagged(iColumn)) {
	if (lowerBound(iColumn)) {
	  //sumPerturbCost+=deltaX_[iColumn];
	  deltaObjectiveDual+=deltaZ_[iColumn]*lower_[iColumn];
	} 
	if (upperBound(iColumn)) {
	  //sumPerturbCost-=deltaX_[iColumn];
	  deltaObjectiveDual-=deltaW_[iColumn]*upper_[iColumn];
	} 
	CoinWorkDouble change = CoinAbs(workArray_[iColumn]-deltaZ_[iColumn]+deltaW_[iColumn]);
	error = CoinMax(change,error);
      } 
      deltaObjectivePrimal += cost_[iColumn] * deltaX_[iColumn];
    } 
    //deltaObjectivePrimal+=sumPerturbCost*linearPerturbation_;
    CoinWorkDouble testValue;
    if (error>0.0) {
      testValue=1.0e1*CoinMax(maximumDualError_,1.0e-12)/error;
    } else {
      testValue=1.0e1;
    } 
    // If quadratic then primal step may compensate
    if (testValue<actualDualStep_&&!quadraticObj) {
      handler_->message(CLP_BARRIER_REDUCING,messages_)
	<<"dual"<<static_cast<double>(actualDualStep_)
	<< static_cast<double>(testValue)
      <<CoinMessageEol;
      actualDualStep_=testValue;
    } 
  } 
  if (maximumRHSError_<1.0e1*solutionNorm_*primalTolerance()
                            &&maximumRHSChange_>1.0e-16*solutionNorm_) {
    //check change in AX not too much
    //??? could be dropped row going infeasible
    CoinWorkDouble ratio = 1.0e1*CoinMax(maximumRHSError_,1.0e-12)/maximumRHSChange_;
    if (ratio<actualPrimalStep_) {
      handler_->message(CLP_BARRIER_REDUCING,messages_)
	<<"primal"<<static_cast<double>(actualPrimalStep_)
	<<static_cast<double>(ratio)
      <<CoinMessageEol;
      if (ratio>1.0e-6) {
        actualPrimalStep_=ratio;
      } else {
        actualPrimalStep_=ratio;
        //std::cout <<"sign we should be stopping"<<std::endl;
      } 
    } 
  }
  if (goodMove)
    bestNextGap=returnGap;
  return goodMove;
}
//:  checks for one step size
bool ClpPredictorCorrector::checkGoodMove2(CoinWorkDouble move,
					   CoinWorkDouble & bestNextGap,
					   bool allowIncreasingGap)
{
  CoinWorkDouble complementarityMultiplier =1.0/numberComplementarityPairs_;
  const CoinWorkDouble gamma = 1.0e-8;
  const CoinWorkDouble gammap = 1.0e-8;
  CoinWorkDouble gammad = 1.0e-8;
  int nextNumber;
  int nextNumberItems;
  CoinWorkDouble nextGap=complementarityGap(nextNumber,nextNumberItems,2);
  if (nextGap>bestNextGap&&!allowIncreasingGap)
    return false;
  CoinWorkDouble lowerBoundGap = gamma*nextGap*complementarityMultiplier;
  bool goodMove=true;
  int iColumn;
  for ( iColumn=0;iColumn<numberRows_+numberColumns_;iColumn++) {
    if (!flagged(iColumn)) {
      if (lowerBound(iColumn)) {
	CoinWorkDouble part1=lowerSlack_[iColumn]+actualPrimalStep_*deltaSL_[iColumn];
	CoinWorkDouble part2=zVec_[iColumn]+actualDualStep_*deltaZ_[iColumn];
	if (part1*part2<lowerBoundGap) {
	  goodMove=false;
	  break;
	} 
      } 
      if (upperBound(iColumn)) {
	CoinWorkDouble part1=upperSlack_[iColumn]+actualPrimalStep_*deltaSU_[iColumn];
	CoinWorkDouble part2=wVec_[iColumn]+actualDualStep_*deltaW_[iColumn];
	if (part1*part2<lowerBoundGap) {
	  goodMove=false;
	  break;
	} 
      } 
    } 
  } 
   CoinWorkDouble * nextDj=NULL;
   CoinWorkDouble maximumDualError = maximumDualError_;
#ifndef NO_RTTI
  ClpQuadraticObjective * quadraticObj = (dynamic_cast< ClpQuadraticObjective*>(objective_));
#else
  ClpQuadraticObjective * quadraticObj = NULL;
  if (objective_->type()==2)
    quadraticObj = (static_cast< ClpQuadraticObjective*>(objective_));
#endif
  CoinWorkDouble * dualArray = reinterpret_cast<CoinWorkDouble *>(dual_);
  if (quadraticObj) {
    // change gammad
    gammad=1.0e-4;
    CoinWorkDouble gamma2 = gamma_*gamma_;
    nextDj = new CoinWorkDouble [numberColumns_];
    CoinWorkDouble * nextSolution = new CoinWorkDouble [numberColumns_];
    // put next primal into nextSolution
    for ( iColumn=0;iColumn<numberColumns_;iColumn++) {
      if (!flagged(iColumn)) {
	nextSolution[iColumn]=solution_[iColumn]+
	  actualPrimalStep_*deltaX_[iColumn];
      } else {
	nextSolution[iColumn]=solution_[iColumn];
      }
    }
    // do reduced costs
    CoinMemcpyN(cost_,numberColumns_,nextDj);
    matrix_->transposeTimes(-1.0,dualArray,nextDj);
    matrix_->transposeTimes(-actualDualStep_,deltaY_,nextDj);
    quadraticDjs(nextDj,nextSolution,1.0);
    delete [] nextSolution;
    CoinPackedMatrix * quadratic = quadraticObj->quadraticObjective();
    const int * columnQuadraticLength = quadratic->getVectorLengths();
    for (int iColumn=0;iColumn<numberColumns_;iColumn++) {
      if (!fixedOrFree(iColumn)) {
	CoinWorkDouble newZ=0.0;
	CoinWorkDouble newW=0.0;
	if (lowerBound(iColumn)) {
          newZ=zVec_[iColumn]+actualDualStep_*deltaZ_[iColumn];
        } 
	if (upperBound(iColumn)) {
          newW=wVec_[iColumn]+actualDualStep_*deltaW_[iColumn];
	} 
	if (columnQuadraticLength[iColumn]) {
	  CoinWorkDouble gammaTerm = gamma2;
	  if (primalR_)
	    gammaTerm += primalR_[iColumn];
	  //CoinWorkDouble dualInfeasibility=
	  //dj_[iColumn]-zVec_[iColumn]+wVec_[iColumn]
	  //+gammaTerm*solution_[iColumn];
	  CoinWorkDouble newInfeasibility=
	    nextDj[iColumn]-newZ+newW
	    +gammaTerm*(solution_[iColumn]+actualPrimalStep_*deltaX_[iColumn]);
	  maximumDualError = CoinMax(maximumDualError,newInfeasibility);
	  //if (CoinAbs(newInfeasibility)>CoinMax(2000.0*maximumDualError_,1.0e-2)) {
	  //if (dualInfeasibility*newInfeasibility<0.0) {
	  //  printf("%d current %g next %g\n",iColumn,dualInfeasibility,
	  //       newInfeasibility);
	  //  goodMove=false;
	  //}
	  //}
	}
      } 
    }
    delete [] nextDj;
  }
 //      Satisfy g_p(alpha)?
  if (rhsNorm_>solutionNorm_) {
    solutionNorm_=rhsNorm_;
  } 
  CoinWorkDouble errorCheck=maximumRHSError_/solutionNorm_;
  if (errorCheck<maximumBoundInfeasibility_) {
    errorCheck=maximumBoundInfeasibility_;
  } 
  // scale back move
  move = CoinMin(move,0.95);
  //scale
  if ((1.0-move)*errorCheck>primalTolerance()) {
    if (nextGap<gammap*(1.0-move)*errorCheck) {
      goodMove=false;
    } 
  } 
  //      Satisfy g_d(alpha)?
  errorCheck=maximumDualError/objectiveNorm_;
  if ((1.0-move)*errorCheck>dualTolerance()) {
    if (nextGap<gammad*(1.0-move)*errorCheck) {
      goodMove=false;
    } 
  }
  if (goodMove)
    bestNextGap=nextGap;
  return goodMove;
}
// updateSolution.  Updates solution at end of iteration
//returns number fixed
int ClpPredictorCorrector::updateSolution(CoinWorkDouble /*nextGap*/)
{
  CoinWorkDouble * dualArray = reinterpret_cast<CoinWorkDouble *>(dual_);
  int numberTotal = numberRows_+numberColumns_;
  //update pi
  multiplyAdd(deltaY_,numberRows_,actualDualStep_,dualArray,1.0);
  CoinZeroN(errorRegion_,numberRows_);
  CoinZeroN(rhsFixRegion_,numberRows_);
  CoinWorkDouble maximumRhsInfeasibility=0.0;
  CoinWorkDouble maximumBoundInfeasibility=0.0;
  CoinWorkDouble maximumDualError=1.0e-12;
  CoinWorkDouble primalObjectiveValue=0.0;
  CoinWorkDouble dualObjectiveValue=0.0;
  CoinWorkDouble solutionNorm=1.0e-12;
  int numberKilled=0;
  CoinWorkDouble freeMultiplier=1.0e6;
  CoinWorkDouble trueNorm =diagonalNorm_/diagonalScaleFactor_;
  if (freeMultiplier<trueNorm) {
    freeMultiplier=trueNorm;
  } 
  if (freeMultiplier>1.0e12) {
    freeMultiplier=1.0e12;
  } 
  freeMultiplier=0.5/freeMultiplier;
  CoinWorkDouble condition = CoinAbs(cholesky_->choleskyCondition());
  bool caution;
  if ((condition<1.0e10&&trueNorm<1.0e12)||numberIterations_<20) {
    caution=false;
  } else {
    caution=true;
  } 
  CoinWorkDouble extra=eExtra;
  const CoinWorkDouble largeFactor=1.0e2;
  CoinWorkDouble largeGap=largeFactor*solutionNorm_;
  if (largeGap<largeFactor) {
    largeGap=largeFactor;
  } 
  CoinWorkDouble dualFake=0.0;
  CoinWorkDouble dualTolerance =  dblParam_[ClpDualTolerance];
  dualTolerance=dualTolerance/scaleFactor_;
  if (dualTolerance<1.0e-12) {
    dualTolerance=1.0e-12;
  } 
  CoinWorkDouble offsetObjective=0.0;
  CoinWorkDouble killTolerance=primalTolerance();
  CoinWorkDouble qDiagonal;
  if (mu_<1.0) {
    qDiagonal=1.0e-8;
  } else {
    qDiagonal=1.0e-8*mu_;
  }
  //CoinWorkDouble nextMu = nextGap/(static_cast<CoinWorkDouble>(2*numberComplementarityPairs_));
  //printf("using gap of %g\n",nextMu);
  //qDiagonal *= 1.0e2;
  //largest allowable ratio of lowerSlack/zVec (etc)
  CoinWorkDouble largestRatio;
  CoinWorkDouble epsilonBase;
  CoinWorkDouble diagonalLimit;
  if (!caution) {
    epsilonBase=eBase;
    largestRatio=eRatio;
    diagonalLimit=eDiagonal;
  } else {
    epsilonBase=eBaseCaution;
    largestRatio=eRatioCaution;
    diagonalLimit=eDiagonalCaution;
  } 
  CoinWorkDouble smallGap=1.0e2;
  CoinWorkDouble maximumDJInfeasibility=0.0;
  int numberIncreased=0;
  int numberDecreased=0;
  CoinWorkDouble largestDiagonal=0.0;
  CoinWorkDouble smallestDiagonal=1.0e50;
  CoinWorkDouble largeGap2 = CoinMax(1.0e7,1.0e2*solutionNorm_);
  //largeGap2 = 1.0e9;
  // When to start looking at killing (factor0
  CoinWorkDouble killFactor;
#ifndef NO_RTTI
  ClpQuadraticObjective * quadraticObj = (dynamic_cast< ClpQuadraticObjective*>(objective_));
#else
  ClpQuadraticObjective * quadraticObj = NULL;
  if (objective_->type()==2)
    quadraticObj = (static_cast< ClpQuadraticObjective*>(objective_));
#endif
#ifndef CLP_CAUTION
#define KILL_ITERATION 50
#else
#if CLP_CAUTION < 1
#define KILL_ITERATION 50
#else
#define KILL_ITERATION 100
#endif
#endif
  if (!quadraticObj||1) {
    if (numberIterations_<KILL_ITERATION) {
      killFactor = 1.0;
    } else if (numberIterations_<2*KILL_ITERATION) {
      killFactor = 5.0;
      stepLength_=CoinMax(stepLength_,0.9995);
    } else if (numberIterations_<4*KILL_ITERATION) {
      killFactor = 20.0;
      stepLength_=CoinMax(stepLength_,0.99995);
    } else {
      killFactor = 1.0e2;
      stepLength_=CoinMax(stepLength_,0.999995);
    }
  } else {
    killFactor=1.0;
  }
  // put next primal into deltaSL_
  int iColumn;
  int iRow;
  for (iColumn=0;iColumn<numberTotal;iColumn++) {
    CoinWorkDouble thisWeight=deltaX_[iColumn];
    CoinWorkDouble newPrimal=solution_[iColumn]+1.0*actualPrimalStep_*thisWeight;
    deltaSL_[iColumn]=newPrimal;
  }
#if 0
  // nice idea but doesn't work
  multiplyAdd(solution_+numberColumns_,numberRows_,-1.0,errorRegion_,0.0);
  matrix_->times(1.0,solution_,errorRegion_);
  multiplyAdd(deltaSL_+numberColumns_,numberRows_,-1.0,rhsFixRegion_,0.0);
  matrix_->times(1.0,deltaSL_,rhsFixRegion_);
  CoinWorkDouble newNorm =  maximumAbsElement(deltaSL_,numberTotal);
  CoinWorkDouble tol = newNorm*primalTolerance();
  bool goneInf=false;
  for (iRow=0;iRow<numberRows_;iRow++) {
    CoinWorkDouble value=errorRegion_[iRow];
    CoinWorkDouble valueNew=rhsFixRegion_[iRow];
    if (CoinAbs(value)<tol&&CoinAbs(valueNew)>tol) {
      printf("row %d old %g new %g\n",iRow,value,valueNew);
      goneInf=true;
    }
  }
  if (goneInf) {
    actualPrimalStep_ *= 0.5;
    for (iColumn=0;iColumn<numberTotal;iColumn++) {
      CoinWorkDouble thisWeight=deltaX_[iColumn];
      CoinWorkDouble newPrimal=solution_[iColumn]+1.0*actualPrimalStep_*thisWeight;
      deltaSL_[iColumn]=newPrimal;
    }
  }
  CoinZeroN(errorRegion_,numberRows_);
  CoinZeroN(rhsFixRegion_,numberRows_);
#endif
  // do reduced costs
  CoinMemcpyN(dualArray,numberRows_,dj_+numberColumns_);
  CoinMemcpyN(cost_,numberColumns_,dj_);
  CoinWorkDouble quadraticOffset=quadraticDjs(dj_,deltaSL_,1.0);
  // Save modified costs for fixed variables
  CoinMemcpyN(dj_,numberColumns_,deltaSU_);
  matrix_->transposeTimes(-1.0,dualArray,dj_);
  CoinWorkDouble gamma2 = gamma_*gamma_; // gamma*gamma will be added to diagonal
  CoinWorkDouble gammaOffset=0.0;
#if 0
  const CoinBigIndex * columnStart = matrix_->getVectorStarts();
  const int * columnLength = matrix_->getVectorLengths();
  const int * row = matrix_->getIndices();
  const double * element = matrix_->getElements();
#endif
  for (iColumn=0;iColumn<numberTotal;iColumn++) {
    if (!flagged(iColumn)) {
      CoinWorkDouble reducedCost=dj_[iColumn];
      bool thisKilled=false;
      CoinWorkDouble zValue = zVec_[iColumn] + actualDualStep_*deltaZ_[iColumn];
      CoinWorkDouble wValue = wVec_[iColumn] + actualDualStep_*deltaW_[iColumn];
      zVec_[iColumn]=zValue;
      wVec_[iColumn]=wValue;
      CoinWorkDouble thisWeight=deltaX_[iColumn];
      CoinWorkDouble oldPrimal = solution_[iColumn];
      CoinWorkDouble newPrimal=solution_[iColumn]+actualPrimalStep_*thisWeight;
      CoinWorkDouble dualObjectiveThis=0.0;
      CoinWorkDouble sUpper=extra;
      CoinWorkDouble sLower=extra;
      CoinWorkDouble kill;
      if (CoinAbs(newPrimal)>1.0e4) {
        kill=killTolerance*1.0e-4*newPrimal;
      } else {
        kill=killTolerance;
      } 
      kill*=1.0e-3;//be conservative
      CoinWorkDouble smallerSlack=COIN_DBL_MAX;
      bool fakeOldBounds=false;
      bool fakeNewBounds=false;
      CoinWorkDouble trueLower;
      CoinWorkDouble trueUpper;
      if (iColumn<numberColumns_) {
	trueLower = columnLower_[iColumn];
	trueUpper = columnUpper_[iColumn];
      } else {
	trueLower = rowLower_[iColumn-numberColumns_];
	trueUpper = rowUpper_[iColumn-numberColumns_];
      }
      if (oldPrimal>trueLower+largeGap2&&
	  oldPrimal<trueUpper-largeGap2)
	fakeOldBounds=true;
      if (newPrimal>trueLower+largeGap2&&
	  newPrimal<trueUpper-largeGap2)
	fakeNewBounds=true;
      if (fakeOldBounds) {
	if (fakeNewBounds) {
	  lower_[iColumn]=newPrimal-largeGap2;
	  lowerSlack_[iColumn] = largeGap2;
	  upper_[iColumn]=newPrimal+largeGap2;
	  upperSlack_[iColumn] = largeGap2;
	} else {
	  lower_[iColumn]=trueLower;
	  setLowerBound(iColumn);
	  lowerSlack_[iColumn] = CoinMax(newPrimal-trueLower,1.0);
	  upper_[iColumn]=trueUpper;
	  setUpperBound(iColumn);
	  upperSlack_[iColumn] = CoinMax(trueUpper-newPrimal,1.0);
	}
      } else if (fakeNewBounds) {
	lower_[iColumn]=newPrimal-largeGap2;
	lowerSlack_[iColumn] = largeGap2;
	upper_[iColumn]=newPrimal+largeGap2;
	upperSlack_[iColumn] = largeGap2;
	// so we can just have one test
	fakeOldBounds=true; 
      }
      CoinWorkDouble lowerBoundInfeasibility=0.0;
      CoinWorkDouble upperBoundInfeasibility=0.0;
      //double saveNewPrimal = newPrimal;
      if (lowerBound(iColumn)) {
        CoinWorkDouble oldSlack = lowerSlack_[iColumn];
        CoinWorkDouble newSlack;
	newSlack=
	  lowerSlack_[iColumn]+actualPrimalStep_*(oldPrimal-oldSlack
						 + thisWeight-lower_[iColumn]);
	if (fakeOldBounds)
	  newSlack = lowerSlack_[iColumn];
        CoinWorkDouble epsilon = CoinAbs(newSlack)*epsilonBase;
        epsilon=CoinMin(epsilon,1.0e-5);
	//epsilon=1.0e-14;
        //make sure reasonable
        if (zValue<epsilon) {
          zValue=epsilon;
        } 
        CoinWorkDouble feasibleSlack=newPrimal-lower_[iColumn];
        if (feasibleSlack>0.0&&newSlack>0.0) {
          CoinWorkDouble smallGap2=smallGap;
          if (CoinAbs(0.1*newPrimal)>smallGap) {
            smallGap2=0.1*CoinAbs(newPrimal);
          } 
	  CoinWorkDouble larger;
	  if (newSlack>feasibleSlack) {
	    larger=newSlack;
	  } else {
	    larger=feasibleSlack;
	  } 
	  if (CoinAbs(feasibleSlack-newSlack)<1.0e-6*larger) {
	    newSlack=feasibleSlack;
	  }
        } 
        if (zVec_[iColumn]>dualTolerance) {
          dualObjectiveThis+=lower_[iColumn]*zVec_[iColumn];
        } 
        lowerSlack_[iColumn]=newSlack;
        if (newSlack<smallerSlack) {
          smallerSlack=newSlack;
        } 
	lowerBoundInfeasibility = CoinAbs(newPrimal-lowerSlack_[iColumn]-lower_[iColumn]);
        if (lowerSlack_[iColumn]<=kill*killFactor&&CoinAbs(newPrimal-lower_[iColumn])<=kill*killFactor) {
	  CoinWorkDouble step = CoinMin(actualPrimalStep_*1.1,1.0);
	  CoinWorkDouble newPrimal2=solution_[iColumn]+step*thisWeight;
	  if (newPrimal2<newPrimal&&dj_[iColumn]>1.0e-5&&numberIterations_>50-40) {
	    newPrimal=lower_[iColumn];
	    lowerSlack_[iColumn]=0.0;
	    //printf("fixing %d to lower\n",iColumn);
	  }
	}
        if (lowerSlack_[iColumn]<=kill&&CoinAbs(newPrimal-lower_[iColumn])<=kill) {
          //may be better to leave at value?
          newPrimal=lower_[iColumn];
          lowerSlack_[iColumn]=0.0;
          thisKilled=true;
          //cout<<j<<" l "<<reducedCost<<" "<<zVec_[iColumn]<<endl;
        } else {
          sLower+=lowerSlack_[iColumn];
        } 
      } 
      if (upperBound(iColumn)) {
        CoinWorkDouble oldSlack = upperSlack_[iColumn];
        CoinWorkDouble newSlack;
	newSlack=
	  upperSlack_[iColumn]+actualPrimalStep_*(-oldPrimal-oldSlack
						 - thisWeight+upper_[iColumn]);
	if (fakeOldBounds)
	  newSlack = upperSlack_[iColumn];
        CoinWorkDouble epsilon = CoinAbs(newSlack)*epsilonBase;
        epsilon=CoinMin(epsilon,1.0e-5);
        //make sure reasonable
	//epsilon=1.0e-14;
        if (wValue<epsilon) {
          wValue=epsilon;
        } 
        CoinWorkDouble feasibleSlack=upper_[iColumn]-newPrimal;
        if (feasibleSlack>0.0&&newSlack>0.0) {
          CoinWorkDouble smallGap2=smallGap;
          if (CoinAbs(0.1*newPrimal)>smallGap) {
            smallGap2=0.1*CoinAbs(newPrimal);
          } 
	  CoinWorkDouble larger;
	  if (newSlack>feasibleSlack) {
	    larger=newSlack;
	  } else {
	    larger=feasibleSlack;
	  } 
	  if (CoinAbs(feasibleSlack-newSlack)<1.0e-6*larger) {
	    newSlack=feasibleSlack;
	  }
        } 
        if (wVec_[iColumn]>dualTolerance) {
          dualObjectiveThis-=upper_[iColumn]*wVec_[iColumn];
        } 
        upperSlack_[iColumn]=newSlack;
        if (newSlack<smallerSlack) {
          smallerSlack=newSlack;
        } 
	upperBoundInfeasibility = CoinAbs(newPrimal+upperSlack_[iColumn]-upper_[iColumn]);
        if (upperSlack_[iColumn]<=kill*killFactor&&CoinAbs(newPrimal-upper_[iColumn])<=kill*killFactor) {
	  CoinWorkDouble step = CoinMin(actualPrimalStep_*1.1,1.0);
	  CoinWorkDouble newPrimal2=solution_[iColumn]+step*thisWeight;
	  if (newPrimal2>newPrimal&&dj_[iColumn]<-1.0e-5&&numberIterations_>50-40) {
	    newPrimal=upper_[iColumn];
	    upperSlack_[iColumn]=0.0;
	    //printf("fixing %d to upper\n",iColumn);
	  }
	}
        if (upperSlack_[iColumn]<=kill&&CoinAbs(newPrimal-upper_[iColumn])<=kill) {
          //may be better to leave at value?
          newPrimal=upper_[iColumn];
          upperSlack_[iColumn]=0.0;
          thisKilled=true;
        } else {
          sUpper+=upperSlack_[iColumn];
        } 
      } 
#if 0
      if (newPrimal!=saveNewPrimal&&iColumn<numberColumns_) {
	// adjust slacks
	double movement = newPrimal-saveNewPrimal;
	for (CoinBigIndex j=columnStart[iColumn];
	     j<columnStart[iColumn]+columnLength[iColumn];j++) {
	  int iRow = row[j];
	  double slackMovement = element[j]*movement;
	  solution_[iRow+numberColumns_] += slackMovement; // sign?
	}
      }
#endif
      solution_[iColumn]=newPrimal;
      if (CoinAbs(newPrimal)>solutionNorm) {
        solutionNorm=CoinAbs(newPrimal);
      } 
      if (!thisKilled) {
	CoinWorkDouble gammaTerm = gamma2;
	if (primalR_) {
	  gammaTerm += primalR_[iColumn];
	  quadraticOffset += newPrimal*newPrimal*primalR_[iColumn];
	}
        CoinWorkDouble dualInfeasibility=
	  reducedCost-zVec_[iColumn]+wVec_[iColumn]+gammaTerm*newPrimal;
        if (CoinAbs(dualInfeasibility)>dualTolerance) {
#if 0
	  if (dualInfeasibility>0.0) {
	    // To improve we could reduce t and/or increase z
	    if (lowerBound(iColumn)) {
	      CoinWorkDouble complementarity =zVec_[iColumn]*lowerSlack_[iColumn];
	      if (complementarity<nextMu) {
		CoinWorkDouble change=
		  CoinMin(dualInfeasibility,
		      (nextMu-complementarity)/lowerSlack_[iColumn]);
		dualInfeasibility -= change;
		printf("%d lb locomp %g - dual inf from %g to %g\n",
		       iColumn,complementarity,dualInfeasibility+change,
		       dualInfeasibility);
		zVec_[iColumn] += change;
		zValue = CoinMax(zVec_[iColumn],1.0e-12);
	      }
	    }
	    if (upperBound(iColumn)) {
	      CoinWorkDouble complementarity =wVec_[iColumn]*upperSlack_[iColumn];
	      if (complementarity>nextMu) {
		CoinWorkDouble change=
		  CoinMin(dualInfeasibility,
		      (complementarity-nextMu)/upperSlack_[iColumn]);
		dualInfeasibility -= change;
		printf("%d ub hicomp %g - dual inf from %g to %g\n",
		       iColumn,complementarity,dualInfeasibility+change,
		       dualInfeasibility);
		wVec_[iColumn] -= change;
		wValue = CoinMax(wVec_[iColumn],1.0e-12);
	      }
	    }
	  } else {
	    // To improve we could reduce z and/or increase t
	    if (lowerBound(iColumn)) {
	      CoinWorkDouble complementarity =zVec_[iColumn]*lowerSlack_[iColumn];
	      if (complementarity>nextMu) {
		CoinWorkDouble change=
		  CoinMax(dualInfeasibility,
		      (nextMu-complementarity)/lowerSlack_[iColumn]);
		dualInfeasibility -= change;
		printf("%d lb hicomp %g - dual inf from %g to %g\n",
		       iColumn,complementarity,dualInfeasibility+change,
		       dualInfeasibility);
		zVec_[iColumn] += change;
		zValue = CoinMax(zVec_[iColumn],1.0e-12);
	      }
	    }
	    if (upperBound(iColumn)) {
	      CoinWorkDouble complementarity =wVec_[iColumn]*upperSlack_[iColumn];
	      if (complementarity<nextMu) {
		CoinWorkDouble change=
		  CoinMax(dualInfeasibility,
		      (complementarity-nextMu)/upperSlack_[iColumn]);
		dualInfeasibility -= change;
		printf("%d ub locomp %g - dual inf from %g to %g\n",
		       iColumn,complementarity,dualInfeasibility+change,
		       dualInfeasibility);
		wVec_[iColumn] -= change;
		wValue = CoinMax(wVec_[iColumn],1.0e-12);
	      }
	    }
	  }
#endif
	  dualFake+=newPrimal*dualInfeasibility;
        } 
	if (lowerBoundInfeasibility>maximumBoundInfeasibility) {
	  maximumBoundInfeasibility=lowerBoundInfeasibility;
	} 
	if (upperBoundInfeasibility>maximumBoundInfeasibility) {
	  maximumBoundInfeasibility=upperBoundInfeasibility;
	} 
        dualInfeasibility=CoinAbs(dualInfeasibility);
        if (dualInfeasibility>maximumDualError) {
	  //printf("bad dual %d %g\n",iColumn,
	  // reducedCost-zVec_[iColumn]+wVec_[iColumn]+gammaTerm*newPrimal);
          maximumDualError=dualInfeasibility;
        } 
        dualObjectiveValue+=dualObjectiveThis;
	gammaOffset += newPrimal*newPrimal;
        if (sLower>largeGap) {
          sLower=largeGap;
        } 
        if (sUpper>largeGap) {
          sUpper=largeGap;
        } 
#if 1
        CoinWorkDouble divisor = sLower*wValue+sUpper*zValue+gammaTerm*sLower*sUpper;
        CoinWorkDouble diagonalValue=(sUpper*sLower)/divisor;
#else
        CoinWorkDouble divisor = sLower*wValue+sUpper*zValue+gammaTerm*sLower*sUpper;
        CoinWorkDouble diagonalValue2=(sUpper*sLower)/divisor;
	CoinWorkDouble diagonalValue;
	if (!lowerBound(iColumn)) {
	  diagonalValue = wValue/sUpper + gammaTerm;
	} else if (!upperBound(iColumn)) {
	  diagonalValue = zValue/sLower + gammaTerm;
	} else {
	  diagonalValue = zValue/sLower + wValue/sUpper + gammaTerm;
	}
	diagonalValue = 1.0/diagonalValue;
#endif
        diagonal_[iColumn]=diagonalValue;
        //FUDGE
        if (diagonalValue>diagonalLimit) {
#ifdef COIN_DEVELOP
          std::cout<<"large diagonal "<<diagonalValue<<std::endl;
#endif
          diagonal_[iColumn]=diagonalLimit;
        } 
#ifdef COIN_DEVELOP
        if (diagonalValue<1.0e-10) {
          //std::cout<<"small diagonal "<<diagonalValue<<std::endl;
        }
#endif 
        if (diagonalValue>largestDiagonal) {
          largestDiagonal=diagonalValue;
        } 
        if (diagonalValue<smallestDiagonal) {
          smallestDiagonal=diagonalValue;
        } 
        deltaX_[iColumn]=0.0;
      } else {
        numberKilled++;
	if (solution_[iColumn]!=lower_[iColumn]&&
	    solution_[iColumn]!=upper_[iColumn]) {
	  printf("%d %g %g %g\n",iColumn,static_cast<double>(lower_[iColumn]),
		 static_cast<double>(solution_[iColumn]),static_cast<double>(upper_[iColumn]));
	}
        diagonal_[iColumn]=0.0;
        zVec_[iColumn]=0.0;
        wVec_[iColumn]=0.0;
        setFlagged(iColumn);
        setFixedOrFree(iColumn);
        deltaX_[iColumn]=newPrimal;
	offsetObjective+=newPrimal*deltaSU_[iColumn];
      } 
    } else {
      deltaX_[iColumn]=solution_[iColumn];
      diagonal_[iColumn]=0.0;
      offsetObjective+=solution_[iColumn]*deltaSU_[iColumn];
      if (upper_[iColumn]-lower_[iColumn]>1.0e-5) {
        if (solution_[iColumn]<lower_[iColumn]+1.0e-8&&dj_[iColumn]<-1.0e-8) {
          if (-dj_[iColumn]>maximumDJInfeasibility) {
            maximumDJInfeasibility=-dj_[iColumn];
          } 
        } 
        if (solution_[iColumn]>upper_[iColumn]-1.0e-8&&dj_[iColumn]>1.0e-8) {
          if (dj_[iColumn]>maximumDJInfeasibility) {
            maximumDJInfeasibility=dj_[iColumn];
          } 
        } 
      } 
    } 
    primalObjectiveValue+=solution_[iColumn]*cost_[iColumn];
  }
  handler_->message(CLP_BARRIER_DIAGONAL,messages_)
    <<static_cast<double>(largestDiagonal)<<static_cast<double>(smallestDiagonal)
    <<CoinMessageEol;
#if 0
  // If diagonal wild - kill some
  if (largestDiagonal>1.0e17*smallestDiagonal) {
    CoinWorkDouble killValue =largestDiagonal*1.0e-17;
    for (int iColumn=0;iColumn<numberTotal;iColumn++) {
      if (CoinAbs(diagonal_[iColumn])<killValue)
	diagonal_[iolumn]=0.0;
    }
  }
#endif
  // update rhs region
  multiplyAdd(deltaX_+numberColumns_,numberRows_,-1.0,rhsFixRegion_,1.0);
  matrix_->times(1.0,deltaX_,rhsFixRegion_);
  primalObjectiveValue += 0.5*gamma2*gammaOffset+0.5*quadraticOffset; 
  if (quadraticOffset) {
    //  printf("gamma offset %g %g, quadoffset %g\n",gammaOffset,gamma2*gammaOffset,quadraticOffset);
  }
  
  dualObjectiveValue+=offsetObjective+dualFake;
  dualObjectiveValue -= 0.5*gamma2*gammaOffset+0.5*quadraticOffset; 
  if (numberIncreased||numberDecreased) {
    handler_->message(CLP_BARRIER_SLACKS,messages_)
      <<numberIncreased<<numberDecreased
      <<CoinMessageEol;
  } 
  if (maximumDJInfeasibility) {
    handler_->message(CLP_BARRIER_DUALINF,messages_)
      <<static_cast<double>(maximumDJInfeasibility)
      <<CoinMessageEol;
  } 
  // Need to rethink (but it is only for printing)
  sumPrimalInfeasibilities_=maximumRhsInfeasibility;
  sumDualInfeasibilities_=maximumDualError;
  maximumBoundInfeasibility_ = maximumBoundInfeasibility;
  //compute error and fixed RHS
  multiplyAdd(solution_+numberColumns_,numberRows_,-1.0,errorRegion_,0.0);
  matrix_->times(1.0,solution_,errorRegion_);
  maximumDualError_=maximumDualError;
  maximumBoundInfeasibility_=maximumBoundInfeasibility;
  solutionNorm_=solutionNorm;
  //finish off objective computation
  primalObjective_=primalObjectiveValue*scaleFactor_;
  CoinWorkDouble dualValue2=innerProduct(dualArray,numberRows_,
                rhsFixRegion_);
  dualObjectiveValue-=dualValue2;
  dualObjective_=dualObjectiveValue*scaleFactor_;
  if (numberKilled) {
      handler_->message(CLP_BARRIER_KILLED,messages_)
	<<numberKilled
	<<CoinMessageEol;
  } 
  CoinWorkDouble maximumRHSError1=0.0;
  CoinWorkDouble maximumRHSError2=0.0;
  CoinWorkDouble primalOffset=0.0;
  char * dropped = cholesky_->rowsDropped();
  for (iRow=0;iRow<numberRows_;iRow++) {
    CoinWorkDouble value=errorRegion_[iRow];
    if (!dropped[iRow]) {
      if (CoinAbs(value)>maximumRHSError1) {
	maximumRHSError1=CoinAbs(value);
      } 
    } else {
      if (CoinAbs(value)>maximumRHSError2) {
	maximumRHSError2=CoinAbs(value);
      } 
      primalOffset+=value*dualArray[iRow];
    } 
  } 
  primalObjective_-=primalOffset*scaleFactor_;
  if (maximumRHSError1>maximumRHSError2) {
    maximumRHSError_=maximumRHSError1;
  } else {
    maximumRHSError_=maximumRHSError1; //note change
    if (maximumRHSError2>primalTolerance()) {
      handler_->message(CLP_BARRIER_ABS_DROPPED,messages_)
	<<static_cast<double>(maximumRHSError2)
	<<CoinMessageEol;
    } 
  } 
  objectiveNorm_=maximumAbsElement(dualArray,numberRows_);
  if (objectiveNorm_<1.0e-12) {
    objectiveNorm_=1.0e-12;
  } 
  if (objectiveNorm_<baseObjectiveNorm_) {
    //std::cout<<" base "<<baseObjectiveNorm_<<" "<<objectiveNorm_<<std::endl;
    if (objectiveNorm_<baseObjectiveNorm_*1.0e-4) {
      objectiveNorm_=baseObjectiveNorm_*1.0e-4;
    } 
  } 
  bool primalFeasible=true;
  if (maximumRHSError_>primalTolerance()||
      maximumDualError_>dualTolerance/scaleFactor_) {
    handler_->message(CLP_BARRIER_ABS_ERROR,messages_)
      <<static_cast<double>(maximumRHSError_)<<static_cast<double>(maximumDualError_)
      <<CoinMessageEol;
  } 
  if (rhsNorm_>solutionNorm_) {
    solutionNorm_=rhsNorm_;
  } 
  CoinWorkDouble scaledRHSError=maximumRHSError_/(solutionNorm_+10.0);
  bool dualFeasible=true;
#if KEEP_GOING_IF_FIXED > 5 
  if (maximumBoundInfeasibility_>primalTolerance()||
      scaledRHSError>primalTolerance())
    primalFeasible=false;
#else
  if (maximumBoundInfeasibility_>primalTolerance()||
      scaledRHSError>CoinMax(CoinMin(100.0*primalTolerance(),1.0e-5),
			     primalTolerance()))
    primalFeasible=false;
#endif
  // relax dual test if obj big and gap smallish
  CoinWorkDouble gap=CoinAbs(primalObjective_-dualObjective_);
  CoinWorkDouble sizeObj = CoinMin(CoinAbs(primalObjective_),CoinAbs(dualObjective_))+1.0e-50;
  //printf("gap %g sizeObj %g ratio %g comp %g\n",
  //     gap,sizeObj,gap/sizeObj,complementarityGap_);
  if (numberIterations_>100&&gap/sizeObj<1.0e-9&&complementarityGap_<1.0e-7*sizeObj)
    dualTolerance *= 1.0e2;
  if (maximumDualError_>objectiveNorm_*dualTolerance) 
    dualFeasible=false;
  if (!primalFeasible||!dualFeasible) {
    handler_->message(CLP_BARRIER_FEASIBLE,messages_)
      <<static_cast<double>(maximumBoundInfeasibility_)<<static_cast<double>(scaledRHSError)
      <<static_cast<double>(maximumDualError_/objectiveNorm_)
      <<CoinMessageEol;
  } 
  if (!gonePrimalFeasible_) {
    gonePrimalFeasible_=primalFeasible;
  } else if (!primalFeasible) {
    gonePrimalFeasible_=primalFeasible;
    if (!numberKilled) {
      handler_->message(CLP_BARRIER_GONE_INFEASIBLE,messages_)
      <<CoinMessageEol;
    } 
  } 
  if (!goneDualFeasible_) {
    goneDualFeasible_=dualFeasible;
  } else if (!dualFeasible) {
    handler_->message(CLP_BARRIER_GONE_INFEASIBLE,messages_)
      <<CoinMessageEol;
    goneDualFeasible_=dualFeasible;
  } 
  //objectiveValue();
  if (solutionNorm_>1.0e40) {
    std::cout <<"primal off to infinity"<<std::endl;
    abort();
  } 
  if (objectiveNorm_>1.0e40) {
    std::cout <<"dual off to infinity"<<std::endl;
    abort();
  } 
  handler_->message(CLP_BARRIER_STEP,messages_)
    <<static_cast<double>(actualPrimalStep_)
    <<static_cast<double>(actualDualStep_)
    <<static_cast<double>(mu_)
    <<CoinMessageEol;
  numberIterations_++;
  return numberKilled;
}
//  Save info on products of affine deltaSU*deltaW and deltaSL*deltaZ
CoinWorkDouble 
ClpPredictorCorrector::affineProduct()
{
  CoinWorkDouble product = 0.0;
  //IF zVec starts as 0 then deltaZ always zero
  //(remember if free then zVec not 0)
  //I think free can be done with careful use of boundSlacks to zero
  //out all we want
  for (int iColumn=0;iColumn<numberRows_+numberColumns_;iColumn++) {
    CoinWorkDouble w3=deltaZ_[iColumn]*deltaX_[iColumn];
    CoinWorkDouble w4=-deltaW_[iColumn]*deltaX_[iColumn];
    if (lowerBound(iColumn)) {
      w3+=deltaZ_[iColumn]*(solution_[iColumn]-lowerSlack_[iColumn]-lower_[iColumn]);
      product+=w3;
    } 
    if (upperBound(iColumn)) {
      w4+=deltaW_[iColumn]*(-solution_[iColumn]-upperSlack_[iColumn]+upper_[iColumn]);
      product+=w4;
    } 
  } 
  return product;
}
//See exactly what would happen given current deltas
void 
ClpPredictorCorrector::debugMove(int /*phase*/,
				 CoinWorkDouble primalStep, CoinWorkDouble dualStep)
{
#ifndef SOME_DEBUG
  return;
#endif
  CoinWorkDouble * dualArray = reinterpret_cast<CoinWorkDouble *>(dual_);
  int numberTotal = numberRows_+numberColumns_;
  CoinWorkDouble * dualNew = ClpCopyOfArray(dualArray,numberRows_);
  CoinWorkDouble * errorRegionNew = new CoinWorkDouble [numberRows_];
  CoinWorkDouble * rhsFixRegionNew = new CoinWorkDouble [numberRows_];
  CoinWorkDouble * primalNew = ClpCopyOfArray(solution_,numberTotal);
  CoinWorkDouble * djNew = new CoinWorkDouble[numberTotal];
  //update pi
  multiplyAdd(deltaY_,numberRows_,dualStep,dualNew,1.0);
  // do reduced costs
  CoinMemcpyN(dualNew,numberRows_,djNew+numberColumns_);
  CoinMemcpyN(cost_,numberColumns_,djNew);
  matrix_->transposeTimes(-1.0,dualNew,djNew);
  // update x
  int iColumn;
  for (iColumn=0;iColumn<numberTotal;iColumn++) {
    if (!flagged(iColumn)) 
      primalNew[iColumn] +=primalStep*deltaX_[iColumn];
  }
  CoinWorkDouble quadraticOffset=quadraticDjs(djNew,primalNew,1.0);
  CoinZeroN(errorRegionNew,numberRows_);
  CoinZeroN(rhsFixRegionNew,numberRows_);
  CoinWorkDouble maximumBoundInfeasibility=0.0;
  CoinWorkDouble maximumDualError=1.0e-12;
  CoinWorkDouble primalObjectiveValue=0.0;
  CoinWorkDouble dualObjectiveValue=0.0;
  CoinWorkDouble solutionNorm=1.0e-12;
  const CoinWorkDouble largeFactor=1.0e2;
  CoinWorkDouble largeGap=largeFactor*solutionNorm_;
  if (largeGap<largeFactor) {
    largeGap=largeFactor;
  } 
  CoinWorkDouble dualFake=0.0;
  CoinWorkDouble dualTolerance =  dblParam_[ClpDualTolerance];
  dualTolerance=dualTolerance/scaleFactor_;
  if (dualTolerance<1.0e-12) {
    dualTolerance=1.0e-12;
  }
  CoinWorkDouble newGap=0.0;
  CoinWorkDouble offsetObjective=0.0;
  CoinWorkDouble gamma2 = gamma_*gamma_; // gamma*gamma will be added to diagonal
  CoinWorkDouble gammaOffset=0.0;
  CoinWorkDouble maximumDjInfeasibility=0.0;
  for ( iColumn=0;iColumn<numberTotal;iColumn++) {
    if (!flagged(iColumn)) {
      CoinWorkDouble reducedCost=djNew[iColumn];
      CoinWorkDouble zValue = zVec_[iColumn] + dualStep*deltaZ_[iColumn];
      CoinWorkDouble wValue = wVec_[iColumn] + dualStep*deltaW_[iColumn];
      CoinWorkDouble thisWeight=deltaX_[iColumn];
      CoinWorkDouble oldPrimal = solution_[iColumn];
      CoinWorkDouble newPrimal=primalNew[iColumn];
      CoinWorkDouble lowerBoundInfeasibility=0.0;
      CoinWorkDouble upperBoundInfeasibility=0.0;
      if (lowerBound(iColumn)) {
        CoinWorkDouble oldSlack = lowerSlack_[iColumn];
        CoinWorkDouble newSlack=
	  lowerSlack_[iColumn]+primalStep*(oldPrimal-oldSlack
						 + thisWeight-lower_[iColumn]);
        if (zValue>dualTolerance) {
          dualObjectiveValue+=lower_[iColumn]*zVec_[iColumn];
        } 
	lowerBoundInfeasibility = CoinAbs(newPrimal-newSlack-lower_[iColumn]);
	newGap += newSlack*zValue;
      } 
      if (upperBound(iColumn)) {
        CoinWorkDouble oldSlack = upperSlack_[iColumn];
        CoinWorkDouble newSlack=
	  upperSlack_[iColumn]+primalStep*(-oldPrimal-oldSlack
						 - thisWeight+upper_[iColumn]);
        if (wValue>dualTolerance) {
          dualObjectiveValue-=upper_[iColumn]*wVec_[iColumn];
        } 
	upperBoundInfeasibility = CoinAbs(newPrimal+newSlack-upper_[iColumn]);
	newGap += newSlack*wValue;
      } 
      if (CoinAbs(newPrimal)>solutionNorm) {
        solutionNorm=CoinAbs(newPrimal);
      } 
      CoinWorkDouble gammaTerm = gamma2;
      if (primalR_) {
	gammaTerm += primalR_[iColumn];
	quadraticOffset += newPrimal*newPrimal*primalR_[iColumn];
      }
      CoinWorkDouble dualInfeasibility=
	reducedCost-zValue+wValue+gammaTerm*newPrimal;
      if (CoinAbs(dualInfeasibility)>dualTolerance) {
	dualFake+=newPrimal*dualInfeasibility;
      } 
      if (lowerBoundInfeasibility>maximumBoundInfeasibility) {
	maximumBoundInfeasibility=lowerBoundInfeasibility;
      } 
      if (upperBoundInfeasibility>maximumBoundInfeasibility) {
	maximumBoundInfeasibility=upperBoundInfeasibility;
      } 
      dualInfeasibility=CoinAbs(dualInfeasibility);
      if (dualInfeasibility>maximumDualError) {
	//printf("bad dual %d %g\n",iColumn,
	// reducedCost-zVec_[iColumn]+wVec_[iColumn]+gammaTerm*newPrimal);
	maximumDualError=dualInfeasibility;
      } 
      gammaOffset += newPrimal*newPrimal;
      djNew[iColumn]=0.0;
    } else {
      offsetObjective+=primalNew[iColumn]*cost_[iColumn];
      if (upper_[iColumn]-lower_[iColumn]>1.0e-5) {
        if (primalNew[iColumn]<lower_[iColumn]+1.0e-8&&djNew[iColumn]<-1.0e-8) {
          if (-djNew[iColumn]>maximumDjInfeasibility) {
            maximumDjInfeasibility=-djNew[iColumn];
          } 
        } 
        if (primalNew[iColumn]>upper_[iColumn]-1.0e-8&&djNew[iColumn]>1.0e-8) {
          if (djNew[iColumn]>maximumDjInfeasibility) {
            maximumDjInfeasibility=djNew[iColumn];
          } 
        } 
      } 
      djNew[iColumn]=primalNew[iColumn];
    } 
    primalObjectiveValue+=solution_[iColumn]*cost_[iColumn];
  }
  // update rhs region
  multiplyAdd(djNew+numberColumns_,numberRows_,-1.0,rhsFixRegionNew,1.0);
  matrix_->times(1.0,djNew,rhsFixRegionNew);
  primalObjectiveValue += 0.5*gamma2*gammaOffset+0.5*quadraticOffset; 
  dualObjectiveValue+=offsetObjective+dualFake;
  dualObjectiveValue -= 0.5*gamma2*gammaOffset+0.5*quadraticOffset; 
  // Need to rethink (but it is only for printing)
  //compute error and fixed RHS
  multiplyAdd(primalNew+numberColumns_,numberRows_,-1.0,errorRegionNew,0.0);
  matrix_->times(1.0,primalNew,errorRegionNew);
  //finish off objective computation
  CoinWorkDouble primalObjectiveNew=primalObjectiveValue*scaleFactor_;
  CoinWorkDouble dualValue2=innerProduct(dualNew,numberRows_,
                rhsFixRegionNew);
  dualObjectiveValue-=dualValue2;
  //CoinWorkDouble dualObjectiveNew=dualObjectiveValue*scaleFactor_;
  CoinWorkDouble maximumRHSError1=0.0;
  CoinWorkDouble maximumRHSError2=0.0;
  CoinWorkDouble primalOffset=0.0;
  char * dropped = cholesky_->rowsDropped();
  int iRow;
  for (iRow=0;iRow<numberRows_;iRow++) {
    CoinWorkDouble value=errorRegionNew[iRow];
    if (!dropped[iRow]) {
      if (CoinAbs(value)>maximumRHSError1) {
	maximumRHSError1=CoinAbs(value);
      } 
    } else {
      if (CoinAbs(value)>maximumRHSError2) {
	maximumRHSError2=CoinAbs(value);
      } 
      primalOffset+=value*dualNew[iRow];
    } 
  } 
  primalObjectiveNew-=primalOffset*scaleFactor_;
  CoinWorkDouble maximumRHSError;
  if (maximumRHSError1>maximumRHSError2) {
    maximumRHSError=maximumRHSError1;
  } else {
    maximumRHSError=maximumRHSError1; //note change
    if (maximumRHSError2>primalTolerance()) {
      handler_->message(CLP_BARRIER_ABS_DROPPED,messages_)
	<<static_cast<double>(maximumRHSError2)
	<<CoinMessageEol;
    } 
  }
  /*printf("PH %d %g, %g new comp %g, b %g, p %g, d %g\n",phase,
	 primalStep,dualStep,newGap,maximumBoundInfeasibility,
	 maximumRHSError,maximumDualError);
  if (handler_->logLevel()>1) 
    printf("       objs %g %g\n",
	   primalObjectiveNew,dualObjectiveNew);
  if (maximumDjInfeasibility) {
    printf(" max dj error on fixed %g\n",
	   maximumDjInfeasibility);
	   } */
  delete [] dualNew;
  delete [] errorRegionNew;
  delete [] rhsFixRegionNew;
  delete [] primalNew;
  delete [] djNew;
}
