Functions — github.com/coin-or/Clp

CodeHub MCPcopy Create free account

hub / github.com/coin-or/Clp / functions

Functions3,454 in github.com/coin-or/Clp

⨍ Functions 3,454◇ Types & classes 257

↓ 2 callersMethodreadLp

Read file in LP format (with names)

src/OsiClp/OsiClpSolverInterface.cpp:6223

↓ 2 callersMethodreallyScale

Really scale matrix

src/ClpMatrixBase.cpp:511

↓ 2 callersMethodrefreshFromPerturbed

Refresh - from original

src/AbcNonLinearCost.cpp:135

↓ 2 callersMethodreleasePackedMatrix

Allow any parts of a created CoinMatrix to be deleted

src/ClpNetworkMatrix.cpp:1069

↓ 2 callersMethodreplaceMatrix

And if it does matter (not used at present)

src/OsiClp/OsiClpSolverInterface.cpp:6483

↓ 2 callersMethodresize

Resizes rim part of model

src/ClpSimplex.cpp:13393

↓ 2 callersMethodrowElements

src/AbcMatrix.cpp:3599

↓ 2 callersMethodrowNamesAsChar

Create row names as char

src/ClpModel.cpp:4625

↓ 2 callersFunctionsameTogether

src/ClpSimplexOther.cpp:8108

↓ 2 callersFunctionsaveSolution

Dump a solution to file

src/ClpParamUtils.cpp:459

↓ 2 callersMethodsequenceWithin

Returns sequence number within section

src/AbcSimplex.hpp:733

↓ 2 callersFunctionsetAbcState

src/ClpSimplex.hpp:185

↓ 2 callersMethodsetColLower

Set a single column lower bound<br> Use -DBL_MAX for -infinity. */

src/AbcSimplex.hpp:1096

↓ 2 callersMethodsetColSetBounds

Set the bounds on a number of columns simultaneously<br> @param indexFirst,indexLast pointers to the beginning and after the end of the ar

src/AbcSimplex.hpp:1120

↓ 2 callersFunctionsetDense

src/ClpFactorization.cpp:149

↓ 2 callersFunctionsetNumberDualInfeasibilities

src/ClpSimplex.hpp:753

↓ 2 callersFunctionsetNumberIterations

src/ClpModel.hpp:400

↓ 2 callersFunctionsetNumberPrimalInfeasibilities

src/ClpSimplex.hpp:785

↓ 2 callersMethodsetObjectiveCoefficient

Set an objective function coefficient */

src/ClpModel.cpp:520

↓ 2 callersMethodsetOriginalModel

Set pointer to original model

src/ClpPresolve.cpp:379

↓ 2 callersMethodsetOriginalWanted

src/AbcMatrix.hpp:358

↓ 2 callersFunctionsetSameStatus

src/AbcNonLinearCost.hpp:64

↓ 2 callersMethodsetStrParam

src/ClpModel.cpp:1112

↓ 2 callersFunctionsetSumDualInfeasibilities

src/ClpSimplex.hpp:735

↓ 2 callersFunctionsetSumPrimalInfeasibilities

src/ClpSimplex.hpp:767

↓ 2 callersMethodsetupDualValuesPass

Sets dual values pass djs using unscaled duals type 1 - values pass type 2 - just use as infeasibility weights type 3 - as 2 but crash */

src/AbcSimplex.cpp:730

↓ 2 callersMethodsetupPointers

Sets up all extra pointers

src/AbcSimplex.cpp:130

↓ 2 callersMethodsolveFromHotStart

src/OsiClp/OsiClpSolverInterface.cpp:2464

↓ 2 callersFunctionsolveWithVolume

src/ClpSolve.cpp:238

↓ 2 callersFunctionsortOnOther

src/ClpSolver.cpp:3065

↓ 2 callersFunctionsortOnOther

src/Attic/ClpSolver.cpp:3049

↓ 2 callersFunctionstartColumnR

Start of columns for R

src/CoinAbcBaseFactorization.hpp:316

↓ 2 callersMethodstartParallelStuff

src/AbcSimplexDual.cpp:5815

↓ 2 callersMethodstartParallelTask

src/ClpSimplex.cpp:13581

↓ 2 callersMethodstartupSolve

src/AbcSimplexDual.cpp:221

↓ 2 callersMethodstopParallelStuff

static int count_x[NUMBER_PARALLEL_TASKS]={0,0,0,0,0,0,0,0,0,0}; static int count_y[NUMBER_PARALLEL_TASKS]={0,0,0,0,0,0,0,0,0,0};

src/AbcSimplexDual.cpp:5833

↓ 2 callersFunctionstringValue

src/CbcOrClpParam.hpp:470

↓ 2 callersMethodswapFactorization

Swaps factorization

src/ClpSimplex.cpp:5008

↓ 2 callersMethodswapOne

Swap one variable - when found

src/ClpPackedMatrix.cpp:7702

↓ 2 callersMethodtimeToRefactorize

src/ClpFactorization.cpp:1524

↓ 2 callersFunctiontimedWait

Timed wait in nanoseconds - if negative then seconds

src/AbcSimplexDual.cpp:5697

↓ 2 callersMethodtranslate

src/AbcSimplex.cpp:454

↓ 2 callersMethodtransposeTimesAll

Return y - A * x</code> in <code>y</code>. @pre <code>x</code> must be of size <code>numRows()</code> @pre <code>y</code> must be of size <code>

src/AbcMatrix.cpp:3481

↓ 2 callersMethodtransposeTimesNonBasic

Return A * scalar(+-1) *x + y</code> in <code>y</code>. @pre <code>x</code> must be of size <code>numRows()</code> @pre <code>y</code> must be o

src/AbcMatrix.cpp:3447

↓ 2 callersMethodtransposeTimesSubset

src/ClpPackedMatrix.cpp:614

↓ 2 callersFunctionunsetFlagged

src/ClpDynamicMatrix.hpp:211

↓ 2 callersMethodupdateColumnCpu

Updates one column (FTRAN) */

src/CoinAbcBaseFactorization3.cpp:2350

↓ 2 callersMethodupdateColumnFTPart2

src/CoinAbcBaseFactorization3.cpp:2330

↓ 2 callersMethodupdateCompatibleColsAvg

Update the average number of compatible columns. The input is the number of pivots since last update. */

src/ClpPESimplex.cpp:573

↓ 2 callersMethodupdateCompatibleRowsAvg

Update the average number of compatible rows. The input is the number of pivots since last update. */

src/ClpPESimplex.cpp:583

↓ 2 callersFunctionupdateDualsInDualBit2

The duals are updated by the given arrays.

src/AbcSimplexDual.cpp:541

↓ 2 callersMethodupdatePrimalDegenerates

Updates the set of variables that are not at their bounds */

src/ClpPESimplex.cpp:258

↓ 2 callersMethodupdatePrimalDegeneratesAvg

Update the average number of primal degenerate columns The input is the number of pivots since last update. */

src/ClpPESimplex.cpp:552

↓ 2 callersMethodupdateWeights

Updates weights and returns pivot alpha. Also does FT update */

src/AbcDualRowSteepest.cpp:569

↓ 2 callersMethodupdateWeights1

src/AbcDualRowDantzig.cpp:273

↓ 2 callersFunctionupper

src/ClpSimplex.hpp:1348

↓ 2 callersFunctionuserChoiceValid2

This returns true if chosen in/out pair valid. The main thing to check would be variable flipping bounds may be OK. This would be signaled by r

src/ClpSolver.hpp:134

↓ 2 callersFunctionuserChoiceWasGood

If a good pivot then you may wish to unflag some variables. */

src/ClpSolver.hpp:140

↓ 2 callersFunctionvectorMode

Get vector mode

src/ClpSimplex.hpp:1453

↓ 2 callersMethodwaitAllTasks

src/ClpSimplex.cpp:13651

↓ 2 callersMethodwaitParallelTask

src/ClpSimplex.cpp:13604

↓ 2 callersMethodwhichSet

Returns which set a variable is in

src/ClpDynamicMatrix.cpp:2560

↓ 2 callersMethodwhichThread

so thread can find out which one it is

src/ClpSimplex.cpp:13566

↓ 2 callersFunctionwhichUnsignedChar

src/ClpModel.cpp:4033

↓ 1 callersFunctionClpCholeskyCfactor

Non leaf recursive factor*/

src/ClpCholeskyDense.cpp:697

↓ 1 callersFunctionClpCholeskyCfactorLeaf

Leaf recursive factor*/

src/ClpCholeskyDense.cpp:830

↓ 1 callersFunctionClpCholeskyCrecRecLeaf

Leaf recursive rectangle rectangle update, nUnder is number of rows in iBlock, nUnderK is number of rows in kBlock */

src/ClpCholeskyDense.cpp:1055

↓ 1 callersFunctionClpCholeskyCrecTri

Non leaf recursive rectangle triangle update*/

src/ClpCholeskyDense.cpp:752

↓ 1 callersFunctionClpCholeskyCtriRec

Non leaf recursive triangle rectangle update*/

src/ClpCholeskyDense.cpp:718

↓ 1 callersFunctionClpMain0

src/Attic/ClpSolver.cpp:178

↓ 1 callersFunctionClpSimplexUnitTest

-------------------------------------------------------------------------- test factorization methods and simplex method and simple barrier

src/unitTest.cpp:1407

↓ 1 callersFunctionCoinAbcDlaswp1

src/CoinAbcDenseFactorization.cpp:545

↓ 1 callersFunctionCoinAbcDlaswp1Backwards

src/CoinAbcDenseFactorization.cpp:557

↓ 1 callersFunctionCoinAbcInnerProduct

src/CoinAbcHelperFunctions.cpp:523

↓ 1 callersFunctionCoinAbcMaximumAbsElementAndScale

maximum fabs(region[i]) and then region[i]*=multiplier

src/CoinAbcHelperFunctions.cpp:388

↓ 1 callersFunctionCoinAbcScale

src/CoinAbcHelperFunctions.cpp:350

↓ 1 callersFunctionCoinAbcScatterToList

regionTo[indexScatter[indexList[i]]]=regionFrom[indexList[i]]

src/CoinAbcHelperFunctions.cpp:596

↓ 1 callersFunctionCoinReadGetCommand

src/CbcOrClpParam.cpp:1373

↓ 1 callersFunctionCoinReadGetIntField

valid 0 - okay, 1 bad, 2 not there

src/CbcOrClpParam.cpp:1472

↓ 1 callersFunctionOsiClpHasNDEBUG

So unit test can find out if NDEBUG set

src/OsiClp/OsiClpSolverInterface.cpp:11210

↓ 1 callersFunctionOsiClpSolverInterfaceUnitTest

-------------------------------------------------------------------------- test EKKsolution methods.

test/OsiClpSolverInterfaceTest.cpp:43

↓ 1 callersFunctionPEdot

inner product between a coin vector and a pointer */

src/ClpPESimplex.cpp:20

↓ 1 callersMethodadd

Adds multiple of a column into an CoinIndexedvector You can use quickAdd to add to vector */

src/ClpGubMatrix.cpp:1307

↓ 1 callersMethodaddCol

############################################################################ Problem modifying methods (matrix) ######################################

src/OsiClp/OsiClpSolverInterface.cpp:4347

↓ 1 callersMethodaddRows

-----------------------------------------------------------------------------

src/OsiClp/OsiClpSolverInterface.cpp:4601

↓ 1 callersMethodappendCols

src/ClpPackedMatrix.cpp:5671

↓ 1 callersMethodappendRows

src/ClpPackedMatrix.cpp:5678

↓ 1 callersMethodapplyCuts

src/OsiClp/OsiClpSolverInterface.cpp:5605

↓ 1 callersMethodapplyRowCut

src/OsiClp/OsiClpSolverInterface.cpp:5463

↓ 1 callersMethodapplyRowCuts

Apply a collection of row cuts which are all effective. applyCuts seems to do one at a time which seems inefficient. */

src/OsiClp/OsiClpSolverInterface.cpp:5470

↓ 1 callersMethodback

Last one in (or other criterion)

src/OsiClp/OsiClpSolverInterface.cpp:9144

↓ 1 callersMethodbarrier

Solves using barrier (assumes you have good cholesky factor code). Does crossover to simplex if asked*/

src/ClpSimplex.cpp:6644

↓ 1 callersMethodborrowDiag1

diag1 - we just borrow as it is part of a CoinDenseVector<double>

src/ClpLsqr.hpp:123

↓ 1 callersMethodborrowModel

Borrow model. This is so we dont have to copy large amounts of data around. It assumes a derived class wants to overwrite an empty model with

src/ClpSimplex.cpp:7105

↓ 1 callersFunctionbreakdown

src/ClpSimplexDual.cpp:6485

↓ 1 callersFunctionbuildInfeasible

─── Infeasible LP ─────────────────────────────────────────────────────────── x1 + x2 = 1, x1 + x2 = 2 — clearly infeasible. Extended to n variables t

test/test_racing_lp.cpp:277

↓ 1 callersFunctionbuildUnbounded

─── Unbounded LP ──────────────────────────────────────────────────────────── min -x1 - x2 - ... - xn, x[i] >= 0, no upper bounds, one trivial constra

test/test_racing_lp.cpp:471

↓ 1 callersMethodcanCombine

Returns true if can combine transposeTimes and subsetTransposeTimes and if it would be faster */

src/ClpPackedMatrix.cpp:2371

↓ 1 callersMethodcheckConsistentPivots

For debug - check pivotVariable consistent

src/AbcSimplex.cpp:6259

↓ 1 callersMethodcheckDualSolutionPlusFake

maybe could JUST check against perturbationArray

src/AbcSimplexDual.cpp:4174

← previous next →801–900 of 3,454, ranked by callers