Skip to content

Commit 49f9784

Browse files
a-andresvigerske
a-andre
authored and
svigerske
committed
Replace CoinAbs by std::abs
1 parent 8596ee3 commit 49f9784

9 files changed

+131
-131
lines changed

‎src/CbcOrClpParam.cpp

+1-1
Original file line numberDiff line numberDiff line change
@@ -992,7 +992,7 @@ CbcOrClpParam::setIntParameterWithMessage(CbcModel &model, int value, int &retur
992992
switch (type_) {
993993
case CLP_PARAM_INT_LOGLEVEL:
994994
oldValue = model.messageHandler()->logLevel();
995-
model.messageHandler()->setLogLevel(CoinAbs(value));
995+
model.messageHandler()->setLogLevel(std::abs(value));
996996
break;
997997
case CLP_PARAM_INT_SOLVERLOGLEVEL:
998998
oldValue = model.solver()->messageHandler()->logLevel();

‎src/ClpCholeskyBase.cpp

+27-27
Original file line numberDiff line numberDiff line change
@@ -267,12 +267,12 @@ void ClpCholeskyBase::solveKKT(CoinWorkDouble *region1, CoinWorkDouble *region2,
267267
solve(array);
268268
int iRow;
269269
for (iRow = 0; iRow < numberTotal; iRow++) {
270-
if (rowsDropped_[iRow] && CoinAbs(array[iRow]) > 1.0e-8) {
270+
if (rowsDropped_[iRow] && std::abs(array[iRow]) > 1.0e-8) {
271271
COIN_DETAIL_PRINT(printf("row region1 %d dropped %g\n", iRow, array[iRow]));
272272
}
273273
}
274274
for (; iRow < numberRows_; iRow++) {
275-
if (rowsDropped_[iRow] && CoinAbs(array[iRow]) > 1.0e-8) {
275+
if (rowsDropped_[iRow] && std::abs(array[iRow]) > 1.0e-8) {
276276
COIN_DETAIL_PRINT(printf("row region2 %d dropped %g\n", iRow, array[iRow]));
277277
}
278278
}
@@ -2813,13 +2813,13 @@ int ClpCholeskyBase::factorize(const CoinWorkDouble *diagonal, int *rowsDropped)
28132813
}
28142814
}
28152815
diagonal_[iRow] = work[iRow];
2816-
largest2 = std::max(largest2, CoinAbs(work[iRow]));
2816+
largest2 = std::max(largest2, std::abs(work[iRow]));
28172817
work[iRow] = 0.0;
28182818
int j;
28192819
for (j = 0; j < number; j++) {
28202820
int jRow = which[j];
28212821
put[j] = work[jRow];
2822-
largest2 = std::max(largest2, CoinAbs(work[jRow]));
2822+
largest2 = std::max(largest2, std::abs(work[jRow]));
28232823
work[jRow] = 0.0;
28242824
}
28252825
} else {
@@ -3009,9 +3009,9 @@ int ClpCholeskyBase::factorize(const CoinWorkDouble *diagonal, int *rowsDropped)
30093009
if (iOriginalRow < numberColumns) {
30103010
iColumn = iOriginalRow;
30113011
CoinWorkDouble value = diagonal[iColumn];
3012-
if (CoinAbs(value) > 1.0e-100) {
3012+
if (std::abs(value) > 1.0e-100) {
30133013
value = 1.0 / value;
3014-
largest = std::max(largest, CoinAbs(value));
3014+
largest = std::max(largest, std::abs(value));
30153015
diagonal_[iRow] = -value;
30163016
CoinBigIndex start = columnStart[iColumn];
30173017
CoinBigIndex end = columnStart[iColumn] + columnLength[iColumn];
@@ -3020,17 +3020,17 @@ int ClpCholeskyBase::factorize(const CoinWorkDouble *diagonal, int *rowsDropped)
30203020
kRow = permuteInverse_[kRow];
30213021
if (kRow > iRow) {
30223022
work[kRow] = element[j];
3023-
largest = std::max(largest, CoinAbs(element[j]));
3023+
largest = std::max(largest, std::abs(element[j]));
30243024
}
30253025
}
30263026
} else {
30273027
diagonal_[iRow] = -value;
30283028
}
30293029
} else if (iOriginalRow < numberTotal) {
30303030
CoinWorkDouble value = diagonal[iOriginalRow];
3031-
if (CoinAbs(value) > 1.0e-100) {
3031+
if (std::abs(value) > 1.0e-100) {
30323032
value = 1.0 / value;
3033-
largest = std::max(largest, CoinAbs(value));
3033+
largest = std::max(largest, std::abs(value));
30343034
} else {
30353035
value = 1.0e100;
30363036
}
@@ -3048,7 +3048,7 @@ int ClpCholeskyBase::factorize(const CoinWorkDouble *diagonal, int *rowsDropped)
30483048
int jNewRow = permuteInverse_[jRow];
30493049
if (jNewRow > iRow) {
30503050
work[jNewRow] = elementByRow[j];
3051-
largest = std::max(largest, CoinAbs(elementByRow[j]));
3051+
largest = std::max(largest, std::abs(elementByRow[j]));
30523052
}
30533053
}
30543054
// slack - should it be permute
@@ -3078,7 +3078,7 @@ int ClpCholeskyBase::factorize(const CoinWorkDouble *diagonal, int *rowsDropped)
30783078
CoinBigIndex j;
30793079
iColumn = iOriginalRow;
30803080
CoinWorkDouble value = diagonal[iColumn];
3081-
if (CoinAbs(value) > 1.0e-100) {
3081+
if (std::abs(value) > 1.0e-100) {
30823082
value = 1.0 / value;
30833083
for (j = columnQuadraticStart[iColumn];
30843084
j < columnQuadraticStart[iColumn] + columnQuadraticLength[iColumn]; j++) {
@@ -3090,7 +3090,7 @@ int ClpCholeskyBase::factorize(const CoinWorkDouble *diagonal, int *rowsDropped)
30903090
value += quadraticElement[j];
30913091
}
30923092
}
3093-
largest = std::max(largest, CoinAbs(value));
3093+
largest = std::max(largest, std::abs(value));
30943094
diagonal_[iRow] = -value;
30953095
CoinBigIndex start = columnStart[iColumn];
30963096
CoinBigIndex end = columnStart[iColumn] + columnLength[iColumn];
@@ -3099,17 +3099,17 @@ int ClpCholeskyBase::factorize(const CoinWorkDouble *diagonal, int *rowsDropped)
30993099
kRow = permuteInverse_[kRow];
31003100
if (kRow > iRow) {
31013101
work[kRow] = element[j];
3102-
largest = std::max(largest, CoinAbs(element[j]));
3102+
largest = std::max(largest, std::abs(element[j]));
31033103
}
31043104
}
31053105
} else {
31063106
diagonal_[iRow] = -value;
31073107
}
31083108
} else if (iOriginalRow < numberTotal) {
31093109
CoinWorkDouble value = diagonal[iOriginalRow];
3110-
if (CoinAbs(value) > 1.0e-100) {
3110+
if (std::abs(value) > 1.0e-100) {
31113111
value = 1.0 / value;
3112-
largest = std::max(largest, CoinAbs(value));
3112+
largest = std::max(largest, std::abs(value));
31133113
} else {
31143114
value = 1.0e100;
31153115
}
@@ -3127,7 +3127,7 @@ int ClpCholeskyBase::factorize(const CoinWorkDouble *diagonal, int *rowsDropped)
31273127
int jNewRow = permuteInverse_[jRow];
31283128
if (jNewRow > iRow) {
31293129
work[jNewRow] = elementByRow[j];
3130-
largest = std::max(largest, CoinAbs(elementByRow[j]));
3130+
largest = std::max(largest, std::abs(elementByRow[j]));
31313131
}
31323132
}
31333133
// slack - should it be permute
@@ -3152,17 +3152,17 @@ int ClpCholeskyBase::factorize(const CoinWorkDouble *diagonal, int *rowsDropped)
31523152
longDouble *put = sparseFactor_ + choleskyStart_[iColumn];
31533153
CoinBigIndex *which = choleskyRow_ + indexStart_[iColumn];
31543154
CoinWorkDouble value = diagonal[iColumn];
3155-
if (CoinAbs(value) > 1.0e-100) {
3155+
if (std::abs(value) > 1.0e-100) {
31563156
value = 1.0 / value;
3157-
largest = std::max(largest, CoinAbs(value));
3157+
largest = std::max(largest, std::abs(value));
31583158
diagonal_[iColumn] = -value;
31593159
CoinBigIndex start = columnStart[iColumn];
31603160
CoinBigIndex end = columnStart[iColumn] + columnLength[iColumn];
31613161
for (CoinBigIndex j = start; j < end; j++) {
31623162
//choleskyRow_[numberElements]=row[j]+numberTotal;
31633163
//sparseFactor_[numberElements++]=element[j];
31643164
work[row[j] + numberTotal] = element[j];
3165-
largest = std::max(largest, CoinAbs(element[j]));
3165+
largest = std::max(largest, std::abs(element[j]));
31663166
}
31673167
} else {
31683168
diagonal_[iColumn] = -value;
@@ -3187,7 +3187,7 @@ int ClpCholeskyBase::factorize(const CoinWorkDouble *diagonal, int *rowsDropped)
31873187
int number = choleskyStart_[iColumn + 1] - choleskyStart_[iColumn];
31883188
CoinWorkDouble value = diagonal[iColumn];
31893189
CoinBigIndex j;
3190-
if (CoinAbs(value) > 1.0e-100) {
3190+
if (std::abs(value) > 1.0e-100) {
31913191
value = 1.0 / value;
31923192
for (j = columnQuadraticStart[iColumn];
31933193
j < columnQuadraticStart[iColumn] + columnQuadraticLength[iColumn]; j++) {
@@ -3198,13 +3198,13 @@ int ClpCholeskyBase::factorize(const CoinWorkDouble *diagonal, int *rowsDropped)
31983198
value += quadraticElement[j];
31993199
}
32003200
}
3201-
largest = std::max(largest, CoinAbs(value));
3201+
largest = std::max(largest, std::abs(value));
32023202
diagonal_[iColumn] = -value;
32033203
CoinBigIndex start = columnStart[iColumn];
32043204
CoinBigIndex end = columnStart[iColumn] + columnLength[iColumn];
32053205
for (j = start; j < end; j++) {
32063206
work[row[j] + numberTotal] = element[j];
3207-
largest = std::max(largest, CoinAbs(element[j]));
3207+
largest = std::max(largest, std::abs(element[j]));
32083208
}
32093209
for (j = 0; j < number; j++) {
32103210
int jRow = which[j];
@@ -3226,9 +3226,9 @@ int ClpCholeskyBase::factorize(const CoinWorkDouble *diagonal, int *rowsDropped)
32263226
longDouble *put = sparseFactor_ + choleskyStart_[iColumn];
32273227
CoinBigIndex *which = choleskyRow_ + indexStart_[iColumn];
32283228
CoinWorkDouble value = diagonal[iColumn];
3229-
if (CoinAbs(value) > 1.0e-100) {
3229+
if (std::abs(value) > 1.0e-100) {
32303230
value = 1.0 / value;
3231-
largest = std::max(largest, CoinAbs(value));
3231+
largest = std::max(largest, std::abs(value));
32323232
} else {
32333233
value = 1.0e100;
32343234
}
@@ -3839,7 +3839,7 @@ void ClpCholeskyBase::solve(CoinWorkDouble *region, int type)
38393839
int j;
38403840
double largestO = 0.0;
38413841
for (i = 0; i < numberRows_; i++) {
3842-
largestO = std::max(largestO, CoinAbs(regionX[i]));
3842+
largestO = std::max(largestO, std::abs(regionX[i]));
38433843
}
38443844
for (i = 0; i < numberRows_; i++) {
38453845
int iRow = permute_[i];
@@ -3880,8 +3880,8 @@ void ClpCholeskyBase::solve(CoinWorkDouble *region, int type)
38803880
double largest = 0.0;
38813881
double largestV = 0.0;
38823882
for (i = 0; i < numberRows_; i++) {
3883-
largest = std::max(largest, CoinAbs(region[i] - regionX[i]));
3884-
largestV = std::max(largestV, CoinAbs(region[i]));
3883+
largest = std::max(largest, std::abs(region[i] - regionX[i]));
3884+
largestV = std::max(largestV, std::abs(region[i]));
38853885
}
38863886
printf("largest difference %g, largest %g, largest original %g\n",
38873887
largest, largestV, largestO);

‎src/ClpCholeskyDense.cpp

+13-13
Original file line numberDiff line numberDiff line change
@@ -224,9 +224,9 @@ int ClpCholeskyDense::factorize(const CoinWorkDouble *diagonal, int *rowsDropped
224224
}
225225
}
226226
for (int j = iRow + 1; j < numberRows_; j++)
227-
largest2 = std::max(largest2, CoinAbs(work[j]));
227+
largest2 = std::max(largest2, std::abs(work[j]));
228228
diagonal_[iRow] = diagonalValue;
229-
largest2 = std::max(largest2, CoinAbs(diagonalValue));
229+
largest2 = std::max(largest2, std::abs(diagonalValue));
230230
} else {
231231
/* dropped*/
232232
diagonal_[iRow] = 1.0;
@@ -301,17 +301,17 @@ int ClpCholeskyDense::factorize(const CoinWorkDouble *diagonal, int *rowsDropped
301301
if (!quadratic) {
302302
for (iColumn = 0; iColumn < numberColumns; iColumn++) {
303303
CoinWorkDouble value = diagonal[iColumn];
304-
if (CoinAbs(value) > 1.0e-100) {
304+
if (std::abs(value) > 1.0e-100) {
305305
value = 1.0 / value;
306-
largest = std::max(largest, CoinAbs(value));
306+
largest = std::max(largest, std::abs(value));
307307
diagonal_[iColumn] = -value;
308308
CoinBigIndex start = columnStart[iColumn];
309309
CoinBigIndex end = columnStart[iColumn] + columnLength[iColumn];
310310
for (CoinBigIndex j = start; j < end; j++) {
311311
/*choleskyRow_[numberElements]=row[j]+numberTotal;*/
312312
/*sparseFactor_[numberElements++]=element[j];*/
313313
work[row[j] + numberTotal] = element[j];
314-
largest = std::max(largest, CoinAbs(element[j]));
314+
largest = std::max(largest, std::abs(element[j]));
315315
}
316316
} else {
317317
diagonal_[iColumn] = -value;
@@ -328,7 +328,7 @@ int ClpCholeskyDense::factorize(const CoinWorkDouble *diagonal, int *rowsDropped
328328
for (iColumn = 0; iColumn < numberColumns; iColumn++) {
329329
CoinWorkDouble value = diagonal[iColumn];
330330
CoinBigIndex j;
331-
if (CoinAbs(value) > 1.0e-100) {
331+
if (std::abs(value) > 1.0e-100) {
332332
value = 1.0 / value;
333333
for (j = columnQuadraticStart[iColumn];
334334
j < columnQuadraticStart[iColumn] + columnQuadraticLength[iColumn]; j++) {
@@ -339,13 +339,13 @@ int ClpCholeskyDense::factorize(const CoinWorkDouble *diagonal, int *rowsDropped
339339
value += quadraticElement[j];
340340
}
341341
}
342-
largest = std::max(largest, CoinAbs(value));
342+
largest = std::max(largest, std::abs(value));
343343
diagonal_[iColumn] = -value;
344344
CoinBigIndex start = columnStart[iColumn];
345345
CoinBigIndex end = columnStart[iColumn] + columnLength[iColumn];
346346
for (j = start; j < end; j++) {
347347
work[row[j] + numberTotal] = element[j];
348-
largest = std::max(largest, CoinAbs(element[j]));
348+
largest = std::max(largest, std::abs(element[j]));
349349
}
350350
} else {
351351
value = 1.0e100;
@@ -358,9 +358,9 @@ int ClpCholeskyDense::factorize(const CoinWorkDouble *diagonal, int *rowsDropped
358358
/* slacks*/
359359
for (iColumn = numberColumns; iColumn < numberTotal; iColumn++) {
360360
CoinWorkDouble value = diagonal[iColumn];
361-
if (CoinAbs(value) > 1.0e-100) {
361+
if (std::abs(value) > 1.0e-100) {
362362
value = 1.0 / value;
363-
largest = std::max(largest, CoinAbs(value));
363+
largest = std::max(largest, std::abs(value));
364364
} else {
365365
value = 1.0e100;
366366
}
@@ -656,8 +656,8 @@ void ClpCholeskyDense::factorizePart2(int *rowsDropped)
656656
int numberDropped = 0;
657657
for (int i = 0; i < numberRows_; i++) {
658658
if (diagonal_[i]) {
659-
largest = std::max(largest, CoinAbs(diagonal_[i]));
660-
smallest = std::min(smallest, CoinAbs(diagonal_[i]));
659+
largest = std::max(largest, std::abs(diagonal_[i]));
660+
smallest = std::min(smallest, std::abs(diagonal_[i]));
661661
} else {
662662
numberDropped++;
663663
}
@@ -1312,7 +1312,7 @@ void ClpCholeskyDense::solve(CoinWorkDouble *region)
13121312
#ifdef CHOL_COMPARE
13131313
if (numberRows_ < 200) {
13141314
for (int i = 0; i < numberRows_; i++) {
1315-
assert(CoinAbs(region[i] - region2[i]) < 1.0e-3);
1315+
assert(std::abs(region[i] - region2[i]) < 1.0e-3);
13161316
}
13171317
delete[] region2;
13181318
}

‎src/ClpHelperFunctions.cpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -136,7 +136,7 @@ maximumAbsElement(const CoinWorkDouble *region, int size)
136136
int i;
137137
CoinWorkDouble maxValue = 0.0;
138138
for (i = 0; i < size; i++)
139-
maxValue = std::max(maxValue, CoinAbs(region[i]));
139+
maxValue = std::max(maxValue, std::abs(region[i]));
140140
return maxValue;
141141
}
142142
void setElements(CoinWorkDouble *region, int size, CoinWorkDouble value)
@@ -222,7 +222,7 @@ void getNorms(const CoinWorkDouble *region, int size, CoinWorkDouble &norm1, Coi
222222
int i;
223223
for (i = 0; i < size; i++) {
224224
norm2 += region[i] * region[i];
225-
norm1 = std::max(norm1, CoinAbs(region[i]));
225+
norm1 = std::max(norm1, std::abs(region[i]));
226226
}
227227
}
228228
#endif

0 commit comments

Comments
 (0)