dbldblarith.h File Reference

Detailed Description

defines macros for basic operations in double-double arithmetic giving roughly twice the precision of a double

Author

Leona Gottwald

Definition in file dbldblarith.h.

#include "math.h"

Go to the source code of this file.

Macros
#define	QUAD_EPSILON   1e-12
#define	QUAD_HI(x)   x ## hi
#define	QUAD_LO(x)   x ## lo
#define	QUAD(x)   QUAD_HI(x), QUAD_LO(x)
#define	QUAD_MEMBER(x)   QUAD_HI(x); QUAD_LO(x)
#define	QUAD_TO_DBL(x)   ( QUAD_HI(x) + QUAD_LO(x) )
#define	QUAD_SCALE(x, a)   do { QUAD_HI(x) *= (a); QUAD_LO(x) *= (a); } while(0)
#define	QUAD_ASSIGN(a, constant)   do { QUAD_HI(a) = (constant); QUAD_LO(a) = 0.0; } while(0)
#define	QUAD_ASSIGN_Q(a, b)   do { QUAD_HI(a) = QUAD_HI(b); QUAD_LO(a) = QUAD_LO(b); } while(0)
#define	QUAD_ARRAY_SIZE(size)   ((size)*2)
#define	QUAD_ARRAY_LOAD(r, a, idx)   do { QUAD_HI(r) = (a)[2*(idx)]; QUAD_LO(r) = (a)[2*(idx) + 1]; } while(0)
#define	QUAD_ARRAY_STORE(a, idx, x)   do { (a)[2*(idx)] = QUAD_HI(x); (a)[2*(idx) + 1] = QUAD_LO(x); } while(0)
#define	SCIPquadprecProdDD(r, a, b)   SCIPdbldblProd(QUAD_HI(r), QUAD_LO(r), a, b)
#define	SCIPquadprecSquareD(r, a)   SCIPdbldblSquare(QUAD_HI(r), QUAD_LO(r), a)
#define	SCIPquadprecSumDD(r, a, b)   SCIPdbldblSum(QUAD_HI(r), QUAD_LO(r), a, b)
#define	SCIPquadprecDivDD(r, a, b)   SCIPdbldblDiv(QUAD_HI(r), QUAD_LO(r), a, b)
#define	SCIPquadprecSumQD(r, a, b)   SCIPdbldblSum21(QUAD_HI(r), QUAD_LO(r), QUAD_HI(a), QUAD_LO(a), b)
#define	SCIPquadprecProdQD(r, a, b)   SCIPdbldblProd21(QUAD_HI(r), QUAD_LO(r), QUAD_HI(a), QUAD_LO(a), b)
#define	SCIPquadprecDivDQ(r, a, b)   SCIPdbldblDiv12(QUAD_HI(r), QUAD_LO(r), a, QUAD_HI(b), QUAD_LO(b))
#define	SCIPquadprecDivQD(r, a, b)   SCIPdbldblDiv21(QUAD_HI(r), QUAD_LO(r), QUAD_HI(a), QUAD_LO(a), b)
#define	SCIPquadprecProdQQ(r, a, b)   SCIPdbldblProd22(QUAD_HI(r), QUAD_LO(r), QUAD_HI(a), QUAD_LO(a), QUAD_HI(b), QUAD_LO(b))
#define	SCIPquadprecSumQQ(r, a, b)   SCIPdbldblSum22(QUAD_HI(r), QUAD_LO(r), QUAD_HI(a), QUAD_LO(a), QUAD_HI(b), QUAD_LO(b))
#define	SCIPquadprecSquareQ(r, a)   SCIPdbldblSquare2(QUAD_HI(r), QUAD_LO(r), QUAD_HI(a), QUAD_LO(a))
#define	SCIPquadprecDivQQ(r, a, b)   SCIPdbldblDiv22(QUAD_HI(r), QUAD_LO(r), QUAD_HI(a), QUAD_LO(a), QUAD_HI(b), QUAD_LO(b))
#define	SCIPquadprecSqrtD(r, a)   SCIPdbldblSqrt(QUAD_HI(r), QUAD_LO(r), a)
#define	SCIPquadprecSqrtQ(r, a)   SCIPdbldblSqrt2(QUAD_HI(r), QUAD_LO(r), QUAD_HI(a), QUAD_LO(a))
#define	SCIPquadprecAbsQ(r, a)   SCIPdbldblAbs2(QUAD_HI(r), QUAD_LO(r), QUAD_HI(a), QUAD_LO(a))
#define	SCIPquadprecFloorQ(r, a)   SCIPdbldblFloor2(QUAD_HI(r), QUAD_LO(r), QUAD_HI(a), QUAD_LO(a))
#define	SCIPquadprecCeilQ(r, a)   SCIPdbldblCeil2(QUAD_HI(r), QUAD_LO(r), QUAD_HI(a), QUAD_LO(a))
#define	SCIPquadprecEpsFloorQ(r, a, eps)   SCIPdbldblEpsFloor2(QUAD_HI(r), QUAD_LO(r), QUAD_HI(a), QUAD_LO(a), eps)
#define	SCIPquadprecEpsCeilQ(r, a, eps)   SCIPdbldblEpsCeil2(QUAD_HI(r), QUAD_LO(r), QUAD_HI(a), QUAD_LO(a), eps)
#define	SCIPdbldblProd(rhi, rlo, a, b)
#define	SCIPdbldblSquare(rhi, rlo, a)
#define	SCIPdbldblSum(rhi, rlo, a, b)
#define	SCIPdbldblDiv(rhi, rlo, a, b)
#define	SCIPdbldblSum21(rhi, rlo, ahi, alo, b)
#define	SCIPdbldblProd21(rhi, rlo, ahi, alo, b)
#define	SCIPdbldblDiv12(rhi, rlo, a, bhi, blo)
#define	SCIPdbldblDiv21(rhi, rlo, ahi, alo, b)
#define	SCIPdbldblProd22(rhi, rlo, ahi, alo, bhi, blo)
#define	SCIPdbldblSum22(rhi, rlo, ahi, alo, bhi, blo)
#define	SCIPdbldblSquare2(rhi, rlo, ahi, alo)
#define	SCIPdbldblDiv22(rhi, rlo, ahi, alo, bhi, blo)
#define	SCIPdbldblSqrt(rhi, rlo, a)
#define	SCIPdbldblSqrt2(rhi, rlo, ahi, alo)
#define	SCIPdbldblAbs2(rhi, rlo, ahi, alo)
#define	SCIPdbldblFloor2(rhi, rlo, ahi, alo)
#define	SCIPdbldblCeil2(rhi, rlo, ahi, alo)
#define	SCIPdbldblEpsFloor2(rhi, rlo, ahi, alo, eps)   SCIPdbldblFloor2(rhi, rlo, ahi, (alo) + (eps))
#define	SCIPdbldblEpsCeil2(rhi, rlo, ahi, alo, eps)   SCIPdbldblCeil2(rhi, rlo, ahi, (alo) - (eps))

Macro Definition Documentation

QUAD_EPSILON

#define QUAD_EPSILON   1e-12

Definition at line 42 of file dbldblarith.h.

Referenced by checkDualFeasibility(), chgCoeffWithBound(), chgQuadCoeffWithBound(), constructSNFRelaxation(), cutsRoundMIR(), cutsRoundStrongCG(), cutsSubstituteMIR(), cutsSubstituteStrongCG(), cutsTransformKnapsackCover(), cutsTransformMIR(), cutsTransformStrongCG(), determineBoundForSNF(), evaluateLiftingFunctionKnapsack(), getClosestVlb(), getClosestVub(), removeZeros(), removeZerosQuad(), and SCIPcutGenerationHeuristicCMIR().

QUAD_HI

#define QUAD_HI

(

x

)

x ## hi

Definition at line 45 of file dbldblarith.h.

Referenced by buildFlowCover(), cutsRoundMIR(), cutsRoundStrongCG(), cutsSubstituteMIR(), cutsSubstituteStrongCG(), evaluateLiftingFunction(), performBoundSubstitution(), postprocessCutQuad(), SCIPaggrRowAddCustomCons(), SCIPaggrRowAddObjectiveFunction(), SCIPaggrRowCancelVarWithBound(), SCIPcalcKnapsackCover(), SCIPcalcMIR(), SCIPcalcStrongCG(), SCIPcutGenerationHeuristicCMIR(), varVecAddScaledRowCoefsQuad(), and varVecAddScaledRowCoefsQuadScale().

QUAD_LO

#define QUAD_LO

(

x

)

x ## lo

Definition at line 46 of file dbldblarith.h.

Referenced by SCIPcalcKnapsackCover(), SCIPcalcMIR(), SCIPcalcStrongCG(), and SCIPcutGenerationHeuristicCMIR().

QUAD

#define QUAD

(

x

)

QUAD_HI(x), QUAD_LO(x)

Definition at line 47 of file dbldblarith.h.

Referenced by addCand(), addOneRow(), buildFlowCover(), calcEfficacyDenseStorageQuad(), calcEfficacyNormQuad(), chgCoeffWithBound(), chgQuadCoeffWithBound(), computeBilinEnvelope2(), computeInitialKnapsackCover(), computeLiftingData(), constructSNFRelaxation(), cutsRoundMIR(), cutsRoundStrongCG(), cutsSubstituteMIR(), cutsSubstituteStrongCG(), cutsTransformKnapsackCover(), cutsTransformMIR(), cutsTransformStrongCG(), cutTightenCoefs(), cutTightenCoefsQuad(), determineBoundForSNF(), estimateGradientInner(), evalPhiAtRay(), evaluateLiftingFunction(), evaluateLiftingFunctionKnapsack(), generateLiftedFlowCoverCut(), getAlphaAndBeta(), getClosestVlb(), getClosestVub(), getFlowCover(), getMaxActivity(), getMinActivity(), performBoundSubstitution(), performBoundSubstitutionSimple(), postprocessCut(), postprocessCutQuad(), prepareLiftingData(), propagateCons(), propagateCutoffboundVar(), removeZeros(), removeZerosQuad(), resolvePropagation(), SCIP_DECL_SORTINDCOMP(), SCIPaggrRowAddCustomCons(), SCIPaggrRowAddObjectiveFunction(), SCIPaggrRowAddRow(), SCIPaggrRowCancelVarWithBound(), SCIPaggrRowClear(), SCIPaggrRowGetMinActivity(), SCIPaggrRowGetProbvarValue(), SCIPaggrRowGetValue(), SCIPaggrRowPrint(), SCIPaggrRowRemoveZeros(), SCIPcalcFlowCover(), SCIPcalcKnapsackCover(), SCIPcalcMIR(), SCIPcalcStrongCG(), SCIPcomputeBilinEnvelope1(), SCIPcutGenerationHeuristicCMIR(), SCIPcutsTightenCoefficients(), SCIPundoBdchgsProof(), separateCons(), SORTTPL_NAME(), varVecAddScaledRowCoefsQuad(), and varVecAddScaledRowCoefsQuadScale().

QUAD_MEMBER

#define QUAD_MEMBER

(

x

)

QUAD_HI(x); QUAD_LO(x)

Definition at line 48 of file dbldblarith.h.

Referenced by consdataRecomputeMaxActivityDelta().

QUAD_TO_DBL

#define QUAD_TO_DBL

(

x

)

( QUAD_HI(x) + QUAD_LO(x) )

Definition at line 49 of file dbldblarith.h.

Referenced by addCand(), buildFlowCover(), calcEfficacyDenseStorageQuad(), calcEfficacyNormQuad(), chgCoeffWithBound(), chgQuadCoeffWithBound(), computeBilinEnvelope2(), computeInitialKnapsackCover(), computeLiftingData(), consdataGetMinAbsval(), consdataUpdateActivitiesGlbLb(), consdataUpdateDelCoef(), constructSNFRelaxation(), cutsRoundMIR(), cutsRoundStrongCG(), cutsSubstituteMIR(), cutsSubstituteStrongCG(), cutsTransformKnapsackCover(), cutsTransformMIR(), cutsTransformStrongCG(), cutTightenCoefs(), cutTightenCoefsQuad(), determineBoundForSNF(), estimateGradientInner(), evalPhiAtRay(), evaluateLiftingFunction(), evaluateLiftingFunctionKnapsack(), generateLiftedFlowCoverCut(), getAlphaAndBeta(), getClosestVlb(), getClosestVub(), getFlowCover(), getMaxActivity(), getMinActivity(), postprocessCut(), postprocessCutQuad(), prepareLiftingData(), propagateCons(), propagateCutoffboundVar(), removeZeros(), removeZerosQuad(), resolvePropagation(), SCIP_DECL_SORTINDCOMP(), SCIPaggrRowCancelVarWithBound(), SCIPaggrRowGetMinActivity(), SCIPaggrRowGetProbvarValue(), SCIPaggrRowGetRhs(), SCIPaggrRowGetValue(), SCIPaggrRowPrint(), SCIPcalcFlowCover(), SCIPcalcKnapsackCover(), SCIPcalcMIR(), SCIPcalcStrongCG(), SCIPcomputeBilinEnvelope1(), SCIPcutGenerationHeuristicCMIR(), SCIPcutsTightenCoefficients(), SCIPundoBdchgsProof(), separateCons(), and SORTTPL_NAME().

QUAD_SCALE

#define QUAD_SCALE	(		x,
			a
	)		do { QUAD_HI(x) *= (a); QUAD_LO(x) *= (a); } while(0)

Definition at line 50 of file dbldblarith.h.

Referenced by cutsRoundMIR(), cutsRoundStrongCG(), cutsTransformMIR(), evalPhiAtRay(), and SCIPcomputeBilinEnvelope1().

QUAD_ASSIGN

#define QUAD_ASSIGN	(		a,
			constant
	)		do { QUAD_HI(a) = (constant); QUAD_LO(a) = 0.0; } while(0)

Definition at line 51 of file dbldblarith.h.

Referenced by buildFlowCover(), computeInitialKnapsackCover(), computeLiftingData(), cutsRoundMIR(), cutsRoundStrongCG(), cutsSubstituteMIR(), cutsSubstituteStrongCG(), cutsTransformKnapsackCover(), cutsTransformMIR(), cutsTransformStrongCG(), cutTightenCoefs(), cutTightenCoefsQuad(), estimateGradientInner(), evalPhiAtRay(), evaluateLiftingFunction(), generateLiftedFlowCoverCut(), getFlowCover(), getMaxActivity(), getMinActivity(), postprocessCut(), prepareLiftingData(), removeZeros(), removeZerosQuad(), resolvePropagation(), SCIPaggrRowAddObjectiveFunction(), SCIPaggrRowCancelVarWithBound(), SCIPaggrRowClear(), SCIPaggrRowCreate(), SCIPaggrRowGetMinActivity(), SCIPcalcFlowCover(), SCIPcalcKnapsackCover(), SCIPcalcMIR(), SCIPcalcStrongCG(), SCIPcutGenerationHeuristicCMIR(), SCIPcutsTightenCoefficients(), and SORTTPL_NAME().

QUAD_ASSIGN_Q

#define QUAD_ASSIGN_Q	(		a,
			b
	)		do { QUAD_HI(a) = QUAD_HI(b); QUAD_LO(a) = QUAD_LO(b); } while(0)

Definition at line 52 of file dbldblarith.h.

Referenced by buildFlowCover(), constructSNFRelaxation(), cutsRoundMIR(), cutsRoundStrongCG(), cutsSubstituteStrongCG(), cutTightenCoefs(), cutTightenCoefsQuad(), prepareLiftingData(), SCIPaggrRowCopy(), SCIPcalcKnapsackCover(), SCIPcalcMIR(), SCIPcalcStrongCG(), and SCIPcutGenerationHeuristicCMIR().

QUAD_ARRAY_SIZE

#define QUAD_ARRAY_SIZE

(

size

)

((size)*2)

Definition at line 53 of file dbldblarith.h.

Referenced by SCIPaggrRowCopy(), SCIPaggrRowCreate(), SCIPaggrRowFree(), SCIPcalcKnapsackCover(), SCIPcalcMIR(), SCIPcalcStrongCG(), and SCIPcutGenerationHeuristicCMIR().

QUAD_ARRAY_LOAD

#define QUAD_ARRAY_LOAD	(		r,
			a,
			idx
	)		do { QUAD_HI(r) = (a)[2*(idx)]; QUAD_LO(r) = (a)[2*(idx) + 1]; } while(0)

Definition at line 54 of file dbldblarith.h.

Referenced by calcEfficacyDenseStorageQuad(), calcEfficacyNormQuad(), computeInitialKnapsackCover(), constructSNFRelaxation(), cutsRoundMIR(), cutsRoundStrongCG(), cutsTransformKnapsackCover(), cutsTransformMIR(), cutsTransformStrongCG(), cutTightenCoefsQuad(), determineBoundForSNF(), getClosestVlb(), getClosestVub(), performBoundSubstitution(), performBoundSubstitutionSimple(), postprocessCutQuad(), prepareLiftingData(), removeZerosQuad(), SCIP_DECL_SORTINDCOMP(), SCIPaggrRowAddCustomCons(), SCIPaggrRowAddObjectiveFunction(), SCIPaggrRowCancelVarWithBound(), SCIPaggrRowGetProbvarValue(), SCIPaggrRowGetValue(), SCIPaggrRowPrint(), SCIPcalcKnapsackCover(), SCIPcalcMIR(), SCIPcalcStrongCG(), SCIPcutGenerationHeuristicCMIR(), varVecAddScaledRowCoefsQuad(), and varVecAddScaledRowCoefsQuadScale().

QUAD_ARRAY_STORE

#define QUAD_ARRAY_STORE	(		a,
			idx,
			x
	)		do { (a)[2*(idx)] = QUAD_HI(x); (a)[2*(idx) + 1] = QUAD_LO(x); } while(0)

Definition at line 55 of file dbldblarith.h.

Referenced by cutsRoundMIR(), cutsRoundStrongCG(), cutsTransformKnapsackCover(), cutsTransformMIR(), cutsTransformStrongCG(), cutTightenCoefsQuad(), performBoundSubstitution(), removeZerosQuad(), SCIPaggrRowAddCustomCons(), SCIPaggrRowAddObjectiveFunction(), SCIPaggrRowCancelVarWithBound(), SCIPaggrRowClear(), SCIPcalcKnapsackCover(), SCIPcalcMIR(), SCIPcalcStrongCG(), SCIPcutGenerationHeuristicCMIR(), varVecAddScaledRowCoefsQuad(), and varVecAddScaledRowCoefsQuadScale().

SCIPquadprecProdDD

#define SCIPquadprecProdDD	(		r,
			a,
			b
	)		SCIPdbldblProd(QUAD_HI(r), QUAD_LO(r), a, b)

Definition at line 58 of file dbldblarith.h.

Referenced by addOneRow(), computeBilinEnvelope2(), cutsSubstituteStrongCG(), cutTightenCoefs(), evalPhiAtRay(), evaluateLiftingFunction(), getAlphaAndBeta(), getMaxActivity(), getMinActivity(), propagateCons(), removeZeros(), resolvePropagation(), SCIPaggrRowAddCustomCons(), SCIPaggrRowAddObjectiveFunction(), SCIPaggrRowAddRow(), SCIPaggrRowGetMinActivity(), SCIPcomputeBilinEnvelope1(), SCIPcutGenerationHeuristicCMIR(), SCIPcutsTightenCoefficients(), separateCons(), and varVecAddScaledRowCoefsQuad().

SCIPquadprecSquareD

#define SCIPquadprecSquareD	(		r,
			a
	)		SCIPdbldblSquare(QUAD_HI(r), QUAD_LO(r), a)

Definition at line 59 of file dbldblarith.h.

Referenced by evalPhiAtRay().

SCIPquadprecSumDD

#define SCIPquadprecSumDD	(		r,
			a,
			b
	)		SCIPdbldblSum(QUAD_HI(r), QUAD_LO(r), a, b)

Definition at line 60 of file dbldblarith.h.

Referenced by addCand(), chgCoeffWithBound(), computeBilinEnvelope2(), constructSNFRelaxation(), cutsSubstituteMIR(), cutsTransformMIR(), evaluateLiftingFunction(), generateLiftedFlowCoverCut(), propagateCons(), propagateCutoffboundVar(), resolvePropagation(), SCIPcalcMIR(), SCIPcalcStrongCG(), SCIPcomputeBilinEnvelope1(), SCIPcutGenerationHeuristicCMIR(), SCIPcutsTightenCoefficients(), and SCIPundoBdchgsProof().

SCIPquadprecDivDD

#define SCIPquadprecDivDD	(		r,
			a,
			b
	)		SCIPdbldblDiv(QUAD_HI(r), QUAD_LO(r), a, b)

Definition at line 61 of file dbldblarith.h.

Referenced by cutsRoundStrongCG(), cutsSubstituteStrongCG(), and SCIPcomputeBilinEnvelope1().

SCIPquadprecSumQD

#define SCIPquadprecSumQD	(		r,
			a,
			b
	)		SCIPdbldblSum21(QUAD_HI(r), QUAD_LO(r), QUAD_HI(a), QUAD_LO(a), b)

Definition at line 62 of file dbldblarith.h.

Referenced by buildFlowCover(), chgQuadCoeffWithBound(), computeBilinEnvelope2(), computeLiftingData(), cutsRoundMIR(), cutsRoundStrongCG(), cutsSubstituteMIR(), cutsSubstituteStrongCG(), cutTightenCoefs(), estimateGradientInner(), evalPhiAtRay(), evaluateLiftingFunction(), evaluateLiftingFunctionKnapsack(), generateLiftedFlowCoverCut(), getAlphaAndBeta(), getFlowCover(), propagateCons(), propagateCutoffboundVar(), resolvePropagation(), SCIPcalcKnapsackCover(), SCIPcalcStrongCG(), SCIPcomputeBilinEnvelope1(), SCIPcutsTightenCoefficients(), separateCons(), and SORTTPL_NAME().

SCIPquadprecProdQD

#define SCIPquadprecProdQD	(		r,
			a,
			b
	)		SCIPdbldblProd21(QUAD_HI(r), QUAD_LO(r), QUAD_HI(a), QUAD_LO(a), b)

Definition at line 63 of file dbldblarith.h.

Referenced by addCand(), chgCoeffWithBound(), chgQuadCoeffWithBound(), computeBilinEnvelope2(), constructSNFRelaxation(), cutsRoundMIR(), cutsRoundStrongCG(), cutsSubstituteMIR(), cutsSubstituteStrongCG(), cutTightenCoefs(), cutTightenCoefsQuad(), evalPhiAtRay(), performBoundSubstitution(), performBoundSubstitutionSimple(), prepareLiftingData(), removeZerosQuad(), resolvePropagation(), SCIPaggrRowCancelVarWithBound(), SCIPcalcMIR(), SCIPcalcStrongCG(), SCIPcomputeBilinEnvelope1(), SCIPcutGenerationHeuristicCMIR(), SCIPcutsTightenCoefficients(), SCIPundoBdchgsProof(), and varVecAddScaledRowCoefsQuadScale().

SCIPquadprecDivDQ

#define SCIPquadprecDivDQ	(		r,
			a,
			b
	)		SCIPdbldblDiv12(QUAD_HI(r), QUAD_LO(r), a, QUAD_HI(b), QUAD_LO(b))

Definition at line 64 of file dbldblarith.h.

Referenced by cutsRoundMIR(), cutsRoundStrongCG(), cutsSubstituteMIR(), cutsSubstituteStrongCG(), prepareLiftingData(), and SCIPcalcStrongCG().

SCIPquadprecDivQD

#define SCIPquadprecDivQD	(		r,
			a,
			b
	)		SCIPdbldblDiv21(QUAD_HI(r), QUAD_LO(r), QUAD_HI(a), QUAD_LO(a), b)

Definition at line 65 of file dbldblarith.h.

Referenced by computeBilinEnvelope2(), propagateCons(), propagateCutoffboundVar(), and resolvePropagation().

SCIPquadprecProdQQ

#define SCIPquadprecProdQQ	(		r,
			a,
			b
	)		SCIPdbldblProd22(QUAD_HI(r), QUAD_LO(r), QUAD_HI(a), QUAD_LO(a), QUAD_HI(b), QUAD_LO(b))

Definition at line 66 of file dbldblarith.h.

Referenced by constructSNFRelaxation(), cutsRoundMIR(), cutsRoundStrongCG(), cutsSubstituteMIR(), cutsSubstituteStrongCG(), cutsTransformMIR(), evaluateLiftingFunctionKnapsack(), and SCIPcomputeBilinEnvelope1().

SCIPquadprecSumQQ

#define SCIPquadprecSumQQ	(		r,
			a,
			b
	)		SCIPdbldblSum22(QUAD_HI(r), QUAD_LO(r), QUAD_HI(a), QUAD_LO(a), QUAD_HI(b), QUAD_LO(b))

Definition at line 67 of file dbldblarith.h.

Referenced by addOneRow(), chgCoeffWithBound(), chgQuadCoeffWithBound(), computeBilinEnvelope2(), computeInitialKnapsackCover(), computeLiftingData(), constructSNFRelaxation(), cutsRoundMIR(), cutsRoundStrongCG(), cutsSubstituteMIR(), cutsSubstituteStrongCG(), cutsTransformMIR(), cutTightenCoefs(), cutTightenCoefsQuad(), evalPhiAtRay(), generateLiftedFlowCoverCut(), getMaxActivity(), getMinActivity(), performBoundSubstitution(), performBoundSubstitutionSimple(), prepareLiftingData(), removeZeros(), removeZerosQuad(), resolvePropagation(), SCIPaggrRowAddCustomCons(), SCIPaggrRowAddObjectiveFunction(), SCIPaggrRowAddRow(), SCIPaggrRowCancelVarWithBound(), SCIPaggrRowGetMinActivity(), SCIPcalcMIR(), SCIPcalcStrongCG(), SCIPcomputeBilinEnvelope1(), SCIPcutGenerationHeuristicCMIR(), SCIPcutsTightenCoefficients(), varVecAddScaledRowCoefsQuad(), and varVecAddScaledRowCoefsQuadScale().

SCIPquadprecSquareQ

#define SCIPquadprecSquareQ	(		r,
			a
	)		SCIPdbldblSquare2(QUAD_HI(r), QUAD_LO(r), QUAD_HI(a), QUAD_LO(a))

Definition at line 68 of file dbldblarith.h.

Referenced by computeBilinEnvelope2(), and SCIPcomputeBilinEnvelope1().

SCIPquadprecDivQQ

#define SCIPquadprecDivQQ	(		r,
			a,
			b
	)		SCIPdbldblDiv22(QUAD_HI(r), QUAD_LO(r), QUAD_HI(a), QUAD_LO(a), QUAD_HI(b), QUAD_LO(b))

Definition at line 69 of file dbldblarith.h.

Referenced by computeBilinEnvelope2(), and SCIPcomputeBilinEnvelope1().

SCIPquadprecSqrtD

#define SCIPquadprecSqrtD	(		r,
			a
	)		SCIPdbldblSqrt(QUAD_HI(r), QUAD_LO(r), a)

Definition at line 70 of file dbldblarith.h.

SCIPquadprecSqrtQ

#define SCIPquadprecSqrtQ	(		r,
			a
	)		SCIPdbldblSqrt2(QUAD_HI(r), QUAD_LO(r), QUAD_HI(a), QUAD_LO(a))

Definition at line 71 of file dbldblarith.h.

Referenced by computeBilinEnvelope2(), and evalPhiAtRay().

SCIPquadprecAbsQ

#define SCIPquadprecAbsQ	(		r,
			a
	)		SCIPdbldblAbs2(QUAD_HI(r), QUAD_LO(r), QUAD_HI(a), QUAD_LO(a))

Definition at line 72 of file dbldblarith.h.

SCIPquadprecFloorQ

#define SCIPquadprecFloorQ	(		r,
			a
	)		SCIPdbldblFloor2(QUAD_HI(r), QUAD_LO(r), QUAD_HI(a), QUAD_LO(a))

Definition at line 73 of file dbldblarith.h.

SCIPquadprecCeilQ

#define SCIPquadprecCeilQ	(		r,
			a
	)		SCIPdbldblCeil2(QUAD_HI(r), QUAD_LO(r), QUAD_HI(a), QUAD_LO(a))

Definition at line 74 of file dbldblarith.h.

SCIPquadprecEpsFloorQ

#define SCIPquadprecEpsFloorQ	(		r,
			a,
			eps
	)		SCIPdbldblEpsFloor2(QUAD_HI(r), QUAD_LO(r), QUAD_HI(a), QUAD_LO(a), eps)

Definition at line 75 of file dbldblarith.h.

Referenced by cutsRoundMIR(), cutsRoundStrongCG(), cutsSubstituteMIR(), cutsSubstituteStrongCG(), cutTightenCoefs(), cutTightenCoefsQuad(), SCIPcalcMIR(), SCIPcalcStrongCG(), and SCIPcutGenerationHeuristicCMIR().

SCIPquadprecEpsCeilQ

#define SCIPquadprecEpsCeilQ	(		r,
			a,
			eps
	)		SCIPdbldblEpsCeil2(QUAD_HI(r), QUAD_LO(r), QUAD_HI(a), QUAD_LO(a), eps)

Definition at line 76 of file dbldblarith.h.

Referenced by cutsSubstituteMIR().

SCIPdbldblProd

#define SCIPdbldblProd	(		rhi,
			rlo,
			a,
			b
	)

Value:

do { \
        double __tmp_dbldbl_prod_ahi; \
        double __tmp_dbldbl_prod_alo; \
        double __tmp_dbldbl_prod_bhi; \
        double __tmp_dbldbl_prod_blo; \
        __SCIPdbldblSplit(__tmp_dbldbl_prod_ahi, __tmp_dbldbl_prod_alo, a); \
        __SCIPdbldblSplit(__tmp_dbldbl_prod_bhi, __tmp_dbldbl_prod_blo, b); \
        (rhi) = (a) * (b); \
        (rlo) = __tmp_dbldbl_prod_alo * __tmp_dbldbl_prod_blo - \
           ((((rhi) - __tmp_dbldbl_prod_ahi * __tmp_dbldbl_prod_bhi) \
           - __tmp_dbldbl_prod_alo * __tmp_dbldbl_prod_bhi) \
           - __tmp_dbldbl_prod_ahi * __tmp_dbldbl_prod_blo); \
    } while(0)

multiply two floating point numbers, both given by one double, and return the result as two doubles.

Definition at line 126 of file dbldblarith.h.

SCIPdbldblSquare

#define SCIPdbldblSquare	(		rhi,
			rlo,
			a
	)

Value:

do { \
        double __tmp_dbldbl_square_ahi; \
        double __tmp_dbldbl_square_alo; \
        __SCIPdbldblSplit(__tmp_dbldbl_square_ahi, __tmp_dbldbl_square_alo, a); \
        (rhi) = (a) * (a); \
        (rlo) = __tmp_dbldbl_square_alo * __tmp_dbldbl_square_alo - \
           ((((rhi) - __tmp_dbldbl_square_ahi * __tmp_dbldbl_square_ahi) \
           - 2.0 * __tmp_dbldbl_square_alo * __tmp_dbldbl_square_ahi)); \
    } while(0)

square a floating point number given by one double and return the result as two doubles.

Definition at line 142 of file dbldblarith.h.

SCIPdbldblSum

#define SCIPdbldblSum	(		rhi,
			rlo,
			a,
			b
	)

Value:

do { \
        double __tmp1_dbldbl_sum; \
        double __tmp2_dbldbl_sum; \
        __tmp2_dbldbl_sum = (a) + (b); \
        __tmp1_dbldbl_sum = __tmp2_dbldbl_sum - (a); \
        (rlo) = ((a) - (__tmp2_dbldbl_sum - __tmp1_dbldbl_sum)) + ((b) - __tmp1_dbldbl_sum); \
        (rhi) = __tmp2_dbldbl_sum; \
    } while(0)

add two floating point numbers, both given by one double, and return the result as two doubles.

Definition at line 154 of file dbldblarith.h.

SCIPdbldblDiv

#define SCIPdbldblDiv	(		rhi,
			rlo,
			a,
			b
	)

Value:

do { \
       double __tmp_dbldbl_div_hi; \
       double __tmp_dbldbl_div_lo; \
       double __estim_dbldbl_div = (a)/(b); \
       SCIPdbldblProd(__tmp_dbldbl_div_hi, __tmp_dbldbl_div_lo, b, __estim_dbldbl_div); \
       SCIPdbldblSum21(__tmp_dbldbl_div_hi, __tmp_dbldbl_div_lo, __tmp_dbldbl_div_hi, __tmp_dbldbl_div_lo, -(a)); \
       __tmp_dbldbl_div_hi /= (b); \
       __tmp_dbldbl_div_lo /= (b); \
       SCIPdbldblSum21(rhi, rlo, -__tmp_dbldbl_div_hi, -__tmp_dbldbl_div_lo, __estim_dbldbl_div); \
    } while(0)

divide two floating point numbers, both given by one double, and return the result as two doubles.

Definition at line 165 of file dbldblarith.h.

SCIPdbldblSum21

#define SCIPdbldblSum21	(		rhi,
			rlo,
			ahi,
			alo,
			b
	)

Value:

do { \
      double __tmp_dbldbl_sum21_hi; \
      double __tmp_dbldbl_sum21_lo; \
      SCIPdbldblSum(__tmp_dbldbl_sum21_hi, __tmp_dbldbl_sum21_lo, ahi, b); \
      (rlo) = __tmp_dbldbl_sum21_lo + (alo); \
      (rhi) = __tmp_dbldbl_sum21_hi; \
   } while(0)

add two floating point numbers, the first is given by two doubles, the second is given by one double, and return the result as two doubles.

Definition at line 180 of file dbldblarith.h.

SCIPdbldblProd21

#define SCIPdbldblProd21	(		rhi,
			rlo,
			ahi,
			alo,
			b
	)

Value:

do { \
       double __tmp_dbldbl_prod21_hi; \
       double __tmp_dbldbl_prod21_lo; \
       SCIPdbldblProd(__tmp_dbldbl_prod21_hi, __tmp_dbldbl_prod21_lo, ahi, b); \
       (rlo) = (alo) * (b) + __tmp_dbldbl_prod21_lo; \
       (rhi) = __tmp_dbldbl_prod21_hi; \
    } while(0)

multiply two floating point numbers, the first is given by two doubles, the second is given by one double, and return the result as two doubles.

Definition at line 193 of file dbldblarith.h.

SCIPdbldblDiv12

#define SCIPdbldblDiv12	(		rhi,
			rlo,
			a,
			bhi,
			blo
	)

Value:

do { \
       double __tmp_dbldbl_div12_hi; \
       double __tmp_dbldbl_div12_lo; \
       double __estim_dbldbl_div12 = (a)/(bhi); \
       SCIPdbldblProd21(__tmp_dbldbl_div12_hi, __tmp_dbldbl_div12_lo, bhi, blo, __estim_dbldbl_div12); \
       SCIPdbldblSum21(__tmp_dbldbl_div12_hi, __tmp_dbldbl_div12_lo, __tmp_dbldbl_div12_hi, __tmp_dbldbl_div12_lo, -(a)); \
       __tmp_dbldbl_div12_hi /= (bhi); \
       __tmp_dbldbl_div12_lo /= (bhi); \
       SCIPdbldblSum21(rhi, rlo, -__tmp_dbldbl_div12_hi, -__tmp_dbldbl_div12_lo, __estim_dbldbl_div12); \
    } while(0)

divide two floating point numbers, the first is given by one double, the second is given by two doubles, and return the result as two doubles.

Definition at line 205 of file dbldblarith.h.

SCIPdbldblDiv21

#define SCIPdbldblDiv21	(		rhi,
			rlo,
			ahi,
			alo,
			b
	)

Value:

do { \
      double __tmp_dbldbl_div21_hi; \
      double __tmp_dbldbl_div21_lo; \
      double __estim_dbldbl_div21_hi; \
      double __estim_dbldbl_div21_lo; \
      __estim_dbldbl_div21_hi = (ahi)/(b); \
      __estim_dbldbl_div21_lo = (alo)/(b); \
      SCIPdbldblProd21(__tmp_dbldbl_div21_hi, __tmp_dbldbl_div21_lo, __estim_dbldbl_div21_hi, __estim_dbldbl_div21_lo, b); \
      SCIPdbldblSum22(__tmp_dbldbl_div21_hi, __tmp_dbldbl_div21_lo, __tmp_dbldbl_div21_hi, __tmp_dbldbl_div21_lo, -(ahi), -(alo)); \
      __tmp_dbldbl_div21_hi /= (b); \
      __tmp_dbldbl_div21_lo /= (b); \
      SCIPdbldblSum22(rhi, rlo, __estim_dbldbl_div21_hi, __estim_dbldbl_div21_lo, -__tmp_dbldbl_div21_hi, -__tmp_dbldbl_div21_lo); \
   } while(0)

divide two floating point numbers, the first is given by two doubles, the second is given by one double, and return the result as two doubles.

Definition at line 221 of file dbldblarith.h.

SCIPdbldblProd22

#define SCIPdbldblProd22	(		rhi,
			rlo,
			ahi,
			alo,
			bhi,
			blo
	)

Value:

do { \
      double __tmp_dbldbl_prod22_hi; \
      double __tmp_dbldbl_prod22_lo; \
      SCIPdbldblProd(__tmp_dbldbl_prod22_hi, __tmp_dbldbl_prod22_lo, ahi, bhi); \
      SCIPdbldblSum21(__tmp_dbldbl_prod22_hi, __tmp_dbldbl_prod22_lo, \
                   __tmp_dbldbl_prod22_hi, __tmp_dbldbl_prod22_lo, (alo) * (bhi)); \
      SCIPdbldblSum21(rhi, rlo, \
                   __tmp_dbldbl_prod22_hi, __tmp_dbldbl_prod22_lo, (ahi) * (blo)); \
   } while(0)

multiply two floating point numbers, both given by two doubles, and return the result as two doubles.

Definition at line 237 of file dbldblarith.h.

SCIPdbldblSum22

#define SCIPdbldblSum22	(		rhi,
			rlo,
			ahi,
			alo,
			bhi,
			blo
	)

Value:

do { \
      double __tmp_dbldbl_sum22_hi; \
      double __tmp_dbldbl_sum22_lo; \
      SCIPdbldblSum21(__tmp_dbldbl_sum22_hi, __tmp_dbldbl_sum22_lo, ahi, alo, bhi); \
      SCIPdbldblSum21(rhi, rlo, __tmp_dbldbl_sum22_hi, __tmp_dbldbl_sum22_lo, blo); \
   } while(0)

add two floating point numbers, both given by two doubles, and return the result as two doubles.

Definition at line 249 of file dbldblarith.h.

SCIPdbldblSquare2

#define SCIPdbldblSquare2	(		rhi,
			rlo,
			ahi,
			alo
	)

Value:

do { \
      double __tmp_dbldbl_square2_hi; \
      double __tmp_dbldbl_square2_lo; \
      SCIPdbldblSquare(__tmp_dbldbl_square2_hi, __tmp_dbldbl_square2_lo, (ahi)); \
      SCIPdbldblSum21(rhi, rlo, __tmp_dbldbl_square2_hi, __tmp_dbldbl_square2_lo, 2 * (ahi) * (alo)); \
   } while(0)

square a floating point number given by two doubles and return the result as two doubles.

Definition at line 258 of file dbldblarith.h.

SCIPdbldblDiv22

#define SCIPdbldblDiv22	(		rhi,
			rlo,
			ahi,
			alo,
			bhi,
			blo
	)

Value:

do { \
      double __tmp_dbldbl_div22_hi; \
      double __tmp_dbldbl_div22_lo; \
      double __estim_dbldbl_div22_hi = (ahi) / (bhi); \
      double __estim_dbldbl_div22_lo = (alo) / (bhi); \
      SCIPdbldblProd22(__tmp_dbldbl_div22_hi, __tmp_dbldbl_div22_lo, \
                    bhi, blo, __estim_dbldbl_div22_hi, __estim_dbldbl_div22_lo); \
      SCIPdbldblSum22(__tmp_dbldbl_div22_hi, __tmp_dbldbl_div22_lo, \
                   __tmp_dbldbl_div22_hi, __tmp_dbldbl_div22_lo, -(ahi), -(alo)); \
      __tmp_dbldbl_div22_hi /= (bhi); \
      __tmp_dbldbl_div22_lo /= (bhi); \
      SCIPdbldblSum22(rhi, rlo, __estim_dbldbl_div22_hi, __estim_dbldbl_div22_lo, \
                                -__tmp_dbldbl_div22_hi, -__tmp_dbldbl_div22_lo); \
   } while(0)

divide two floating point numbers, both given by two doubles, and return the result as two doubles.

Definition at line 267 of file dbldblarith.h.

SCIPdbldblSqrt

#define SCIPdbldblSqrt	(		rhi,
			rlo,
			a
	)

Value:

do { \
      double __estim_dbldbl_sqrt = sqrt(a); \
      if( __estim_dbldbl_sqrt != 0.0 ) \
      { \
         SCIPdbldblDiv(rhi, rlo, a, __estim_dbldbl_sqrt); \
         SCIPdbldblSum21(rhi, rlo, rhi, rlo, __estim_dbldbl_sqrt); \
         (rhi) *= 0.5; \
         (rlo) *= 0.5; \
      } \
      else \
      { \
         (rhi) = 0.0; \
         (rlo) = 0.0; \
      } \
   } while(0)

take the square root of a floating point number given by one double and return the result as two doubles.

Definition at line 285 of file dbldblarith.h.

SCIPdbldblSqrt2

#define SCIPdbldblSqrt2	(		rhi,
			rlo,
			ahi,
			alo
	)

Value:

do { \
      double __estim_dbldbl_sqrt2 = sqrt(ahi + alo); \
      if( __estim_dbldbl_sqrt2 != 0.0 ) \
      { \
         SCIPdbldblDiv21(rhi, rlo, ahi, alo, __estim_dbldbl_sqrt2); \
         SCIPdbldblSum21(rhi, rlo, rhi, rlo, __estim_dbldbl_sqrt2); \
         (rhi) *= 0.5; \
         (rlo) *= 0.5; \
      } \
      else \
      { \
         (rhi) = 0.0; \
         (rlo) = 0.0; \
      } \
   } while(0)

take the square root of a floating point number given by two doubles and return the result as two doubles.

Definition at line 304 of file dbldblarith.h.

SCIPdbldblAbs2

#define SCIPdbldblAbs2	(		rhi,
			rlo,
			ahi,
			alo
	)

Value:

do { \
      if( ahi < 0.0 ) \
      { \
         (rhi) = -(ahi); \
         (rlo) = -(alo); \
      } \
      else \
      { \
         (rhi) = (ahi); \
         (rlo) = (alo); \
      } \
   } while(0)

compute the absolute value of the floating point number given by two doubles

Definition at line 322 of file dbldblarith.h.

SCIPdbldblFloor2

#define SCIPdbldblFloor2	(		rhi,
			rlo,
			ahi,
			alo
	)

Value:

do { \
      double __tmp_dbldbl_floor; \
      __tmp_dbldbl_floor = floor((ahi) + (alo)); \
      SCIPdbldblSum21(rhi, rlo, ahi, alo, -__tmp_dbldbl_floor); \
      if( ((rhi) - 1.0) + (rlo) < 0.0 && (rhi) + (rlo) >= 0.0 ) \
      { \
         /* floor in double precision was fine */ \
         (rhi) = __tmp_dbldbl_floor; \
         (rlo) = 0.0; \
      } \
      else \
      { \
         /* floor in double precision needs to be corrected */ \
         double __tmp2_dbldbl_floor = floor((rhi) + (rlo)); \
         SCIPdbldblSum(rhi, rlo, __tmp_dbldbl_floor, __tmp2_dbldbl_floor); \
      } \
   } while(0)

compute the floored value of the floating point number given by two doubles

Definition at line 337 of file dbldblarith.h.

SCIPdbldblCeil2

#define SCIPdbldblCeil2	(		rhi,
			rlo,
			ahi,
			alo
	)

Value:

do { \
      double __tmp_dbldbl_ceil; \
      __tmp_dbldbl_ceil = ceil((ahi) + (alo)); \
      SCIPdbldblSum21(rhi, rlo, -(ahi), -(alo), __tmp_dbldbl_ceil); \
      if( ((rhi) - 1.0) + (rlo) < 0.0 && (rhi) + (rlo) >= 0.0 ) \
      { \
         /* ceil in double precision was fine */ \
         (rhi) = __tmp_dbldbl_ceil; \
         (rlo) = 0.0; \
      } \
      else \
      { \
         /* ceil in double precision needs to be corrected */ \
         double __tmp2_dbldbl_ceil = floor((rhi) + (rlo)); \
         SCIPdbldblSum(rhi, rlo, __tmp_dbldbl_ceil, -__tmp2_dbldbl_ceil); \
      } \
   } while(0)

compute the ceiled value of the floating point number given by two doubles

Definition at line 357 of file dbldblarith.h.

SCIPdbldblEpsFloor2

#define SCIPdbldblEpsFloor2	(		rhi,
			rlo,
			ahi,
			alo,
			eps
	)		SCIPdbldblFloor2(rhi, rlo, ahi, (alo) + (eps))

compute the floored value of the floating point number given by two doubles, add epsilon first for safety

Definition at line 377 of file dbldblarith.h.

SCIPdbldblEpsCeil2

#define SCIPdbldblEpsCeil2	(		rhi,
			rlo,
			ahi,
			alo,
			eps
	)		SCIPdbldblCeil2(rhi, rlo, ahi, (alo) - (eps))

compute the ceiled value of the floating point number given by two doubles, subtract epsilon first for safety

Definition at line 380 of file dbldblarith.h.