Skip to content

Commit 21894d4

Browse files
osander1osander1
committed
Remove some signed/unsigned compiler warnings
1 parent eb28bdb commit 21894d4

File tree

1 file changed

+49
-48
lines changed

1 file changed

+49
-48
lines changed

‎ADOL-C/include/adolc/adtl_hov.h

+49-48
Original file line numberDiff line numberDiff line change
@@ -369,13 +369,13 @@ inline double makeInf() {
369369
return ADOLC_MATH_NSP::numeric_limits<double>::infinity();
370370
}
371371

372-
#define FOR_I_EQ_0_LT_NUMDIR for (int _i = 0; _i < adouble::numDir; ++_i)
372+
#define FOR_I_EQ_0_LT_NUMDIR for (decltype(adouble::numDir) _i = 0; _i < adouble::numDir; ++_i)
373373
#define FOR_J_EQ_0_LT_DEGREE_FOR_I_EQ_0_LT_NUMDIR \
374-
for (int _j = 0; _j < adouble::degree; ++_j) \
375-
for (int _i = 0; _i < adouble::numDir; ++_i)
374+
for (decltype(adouble::degree) _j = 0; _j < adouble::degree; ++_j) \
375+
for (decltype(adouble::numDir) _i = 0; _i < adouble::numDir; ++_i)
376376
#define FOR_I_EQ_0_LT_NUMDIR_FOR_J_EQ_0_LT_DEGREE \
377-
for (int _i = 0; _i < adouble::numDir; ++_i) \
378-
for (int _j = 0; _j < adouble::degree; ++_j)
377+
for (decltype(adouble::numDir) _i = 0; _i < adouble::numDir; ++_i) \
378+
for (decltype(adouble::degree) _j = 0; _j < adouble::degree; ++_j)
379379
#define ADVAL_I adval[_i]
380380
#define ADV_I adv[_i]
381381
#define V_I v[_i]
@@ -647,11 +647,11 @@ inline adouble adouble::operator*(const adouble &a) const {
647647
{
648648
int i;
649649
double sum = 0.0;
650-
for (int l = 0; l < numDir; l++) {
651-
for (int k = 0; k < degree; k++) {
650+
for (size_t l = 0; l < numDir; l++) {
651+
for (size_t k = 0; k < degree; k++) {
652652
sum = val * a.ho_deriv[k][l] + ho_deriv[k][l] * a.val;
653653
i = k - 1;
654-
for (int j = 0; j < k; j++) {
654+
for (size_t j = 0; j < k; j++) {
655655
sum = sum + ho_deriv[j][l] * a.ho_deriv[i - j][l];
656656
}
657657
tmp.ho_deriv[k][l] = sum;
@@ -720,11 +720,11 @@ inline adouble adouble::operator/(const adouble &a) const {
720720
{
721721
int i;
722722
double sum = 0.0;
723-
for (int l = 0; l < adouble::numDir; l++) {
724-
for (int k = 0; k < adouble::degree; k++) {
723+
for (size_t l = 0; l < adouble::numDir; l++) {
724+
for (size_t k = 0; k < adouble::degree; k++) {
725725
sum = tmp.val * a.ho_deriv[k][l];
726726
i = k - 1;
727-
for (int j = 0; j < k; j++) {
727+
for (size_t j = 0; j < k; j++) {
728728
sum += tmp.ho_deriv[j][l] * a.ho_deriv[i - j][l];
729729
}
730730
tmp.ho_deriv[k][l] = (1.0 / a.val) * (ho_deriv[k][l] - sum);
@@ -757,11 +757,11 @@ inline adouble operator/(const double v, const adouble &a) {
757757
{
758758
int i;
759759
double sum = 0.0;
760-
for (int l = 0; l < adouble::numDir; l++) {
761-
for (int k = 0; k < adouble::degree; k++) {
760+
for (size_t l = 0; l < adouble::numDir; l++) {
761+
for (size_t k = 0; k < adouble::degree; k++) {
762762
sum = tmp.val * a.ho_deriv[k][l];
763763
i = k - 1;
764-
for (int j = 0; j < k; j++) {
764+
for (size_t j = 0; j < k; j++) {
765765
sum += tmp.ho_deriv[j][l] * a.ho_deriv[i - j][l];
766766
}
767767
tmp.ho_deriv[k][l] = (1.0 / a.val) * (-sum);
@@ -877,10 +877,10 @@ inline adouble exp(const adouble &a) {
877877
double sum = 0;
878878
int i;
879879
FOR_I_EQ_0_LT_NUMDIR
880-
for (int k = 0; k < adouble::degree; k++) {
880+
for (size_t k = 0; k < adouble::degree; k++) {
881881
sum = tmp.val * (k + 1) * a.ho_deriv[k][_i];
882882
i = k - 1;
883-
for (int j = 0; j < k; j++)
883+
for (size_t j = 0; j < k; j++)
884884
sum += tmp.ho_deriv[i - j][_i] * (j + 1.0) * a.ho_deriv[j][_i];
885885
tmp.ho_deriv[k][_i] = (1.0 / (k + 1)) * sum;
886886
sum = 0.0;
@@ -915,11 +915,11 @@ inline adouble log(const adouble &a) {
915915
{
916916
int i;
917917
double sum = 0.0;
918-
for (int l = 0; l < adouble::numDir; l++) {
919-
for (int k = 0; k < adouble::degree; k++) {
918+
for (size_t l = 0; l < adouble::numDir; l++) {
919+
for (size_t k = 0; k < adouble::degree; k++) {
920920
// ho_deriv[i-j][l]
921921
i = k - 1;
922-
for (int j = 0; j < k; j++)
922+
for (size_t j = 0; j < k; j++)
923923
sum += a.ho_deriv[i - j][l] * (j + 1) * tmp.ho_deriv[j][l];
924924
tmp.ho_deriv[k][l] = (1.0 / (k + 1)) * (1.0 / a.val) *
925925
((k + 1) * a.ho_deriv[k][l] - sum);
@@ -956,11 +956,11 @@ inline adouble sqrt(const adouble &a) {
956956
{
957957
int i;
958958
double sum = 0.0;
959-
for (int l = 0; l < adouble::numDir; l++) {
960-
for (int k = 0; k < adouble::degree; k++) {
959+
for (size_t l = 0; l < adouble::numDir; l++) {
960+
for (size_t k = 0; k < adouble::degree; k++) {
961961
// ho_deriv[i-j][l]
962962
i = k - 1;
963-
for (int j = 0; j < k; j++)
963+
for (size_t j = 0; j < k; j++)
964964
sum += tmp.ho_deriv[j][l] * tmp.ho_deriv[i - j][l];
965965
tmp.ho_deriv[k][l] = 1.0 / (2.0 * tmp.val) * (a.ho_deriv[k][l] - sum);
966966
sum = 0.0;
@@ -999,14 +999,14 @@ inline adouble sin(const adouble &a) {
999999
{
10001000
int i, m;
10011001
double sum1 = 0.0, sum2 = 0.0;
1002-
for (int l = 0; l < adouble::numDir; l++) {
1003-
for (int k = 0; k < adouble::degree; k++) {
1002+
for (size_t l = 0; l < adouble::numDir; l++) {
1003+
for (size_t k = 0; k < adouble::degree; k++) {
10041004
// ho_deriv[k][l]
10051005
m = k + 1;
10061006
sum1 = tmp2.val * m * a.ho_deriv[k][l];
10071007
sum2 = -tmp.val * m * a.ho_deriv[k][l];
10081008
i = k - 1;
1009-
for (int j = 0; j < k; j++) {
1009+
for (size_t j = 0; j < k; j++) {
10101010
sum1 += (j + 1) * a.ho_deriv[j][l] * tmp2.ho_deriv[i - j][l];
10111011
sum2 += -(j + 1) * a.ho_deriv[j][l] * tmp.ho_deriv[i - j][l];
10121012
}
@@ -1042,14 +1042,14 @@ inline adouble cos(const adouble &a) {
10421042
{
10431043
int i, m;
10441044
double sum1 = 0.0, sum2 = 0.0;
1045-
for (int l = 0; l < adouble::numDir; l++) {
1046-
for (int k = 0; k < adouble::degree; k++) {
1045+
for (size_t l = 0; l < adouble::numDir; l++) {
1046+
for (size_t k = 0; k < adouble::degree; k++) {
10471047
// ho_deriv[k][l]
10481048
m = k + 1;
10491049
sum1 = tmp2.val * m * a.ho_deriv[k][l];
10501050
sum2 = -tmp.val * m * a.ho_deriv[k][l];
10511051
i = k - 1;
1052-
for (int j = 0; j < k; j++) {
1052+
for (size_t j = 0; j < k; j++) {
10531053
sum1 += (j + 1) * a.ho_deriv[j][l] * tmp2.ho_deriv[i - j][l];
10541054
sum2 += -(j + 1) * a.ho_deriv[j][l] * tmp.ho_deriv[i - j][l];
10551055
}
@@ -1210,9 +1210,10 @@ inline adouble pow(const adouble &a, double v) {
12101210
// this is different than in GW08. The formula in the table gives a nan
12111211
// for input zero.
12121212
double factorial_val = tgamma(v + 1.0);
1213-
for (int k = 0; k < adouble::degree; k++)
1214-
for (int l = 0; l < adouble::numDir; l++) {
1215-
for (int k = 0; k < adouble::degree;
1213+
for (size_t k = 0; k < adouble::degree; k++)
1214+
for (size_t l = 0; l < adouble::numDir; l++) {
1215+
// TODO: This is shadowing the outer loop variable
1216+
for (size_t k = 0; k < adouble::degree;
12161217
k++) // unsure if this is needed here. keep it for the moment
12171218
// TODO: check if tmp.ho_deriv is zero before here
12181219
{
@@ -1227,12 +1228,12 @@ inline adouble pow(const adouble &a, double v) {
12271228
} else {
12281229
int i;
12291230
double sum1 = 0.0, sum2 = 0.0;
1230-
for (int l = 0; l < adouble::numDir; l++) {
1231-
for (int k = 0; k < adouble::degree; k++) {
1231+
for (size_t l = 0; l < adouble::numDir; l++) {
1232+
for (size_t k = 0; k < adouble::degree; k++) {
12321233
// ho_deriv[k][l]
12331234
sum1 = tmp.val * (k + 1) * a.ho_deriv[k][l];
12341235
i = k - 1;
1235-
for (int j = 0; j < k; j++) {
1236+
for (size_t j = 0; j < k; j++) {
12361237
sum1 += tmp.ho_deriv[i - j][l] * (j + 1) * a.ho_deriv[j][l];
12371238
sum2 += a.ho_deriv[i - j][l] * (1 + j) * tmp.ho_deriv[j][l];
12381239
}
@@ -1299,13 +1300,13 @@ inline adouble pow(double v, const adouble &a) {
12991300
{
13001301
int i;
13011302
double sum;
1302-
for (int l = 0; l < adouble::numDir; l++) {
1303+
for (size_t l = 0; l < adouble::numDir; l++) {
13031304
sum = 0.0;
1304-
for (int k = 0; k < adouble::degree; k++) {
1305+
for (size_t k = 0; k < adouble::degree; k++) {
13051306
// ho_deriv[k][l]
13061307
sum = tmp.val * (k + 1) * a.ho_deriv[k][l];
13071308
i = k - 1;
1308-
for (int j = 0; j < k; j++)
1309+
for (size_t j = 0; j < k; j++)
13091310
sum += tmp.ho_deriv[i - j][l] * (j + 1) * a.ho_deriv[j][l];
13101311
tmp.ho_deriv[k][l] = (1.0 / (k + 1)) * sum * ADOLC_MATH_NSP::log(v);
13111312
sum = 0.0;
@@ -1365,14 +1366,14 @@ inline adouble sinh(const adouble &a) {
13651366
tmp2 = ADOLC_MATH_NSP::cosh(a.val);
13661367
int i, m;
13671368
double sum1 = 0.0, sum2 = 0.0;
1368-
for (int l = 0; l < adouble::numDir; l++) {
1369-
for (int k = 0; k < adouble::degree; k++) {
1369+
for (size_t l = 0; l < adouble::numDir; l++) {
1370+
for (size_t k = 0; k < adouble::degree; k++) {
13701371
// ho_deriv[k][l]
13711372
m = k + 1;
13721373
sum1 = tmp2.val * m * a.ho_deriv[k][l];
13731374
sum2 = tmp.val * m * a.ho_deriv[k][l];
13741375
i = k - 1;
1375-
for (int j = 0; j < k; j++) {
1376+
for (size_t j = 0; j < k; j++) {
13761377
sum1 += (j + 1) * a.ho_deriv[j][l] * tmp2.ho_deriv[i - j][l];
13771378
sum2 += (j + 1) * a.ho_deriv[j][l] * tmp.ho_deriv[i - j][l];
13781379
}
@@ -1409,14 +1410,14 @@ inline adouble cosh(const adouble &a) {
14091410
int i, m;
14101411
double sum1 = 0.0, sum2 = 0.0;
14111412
tmp2 = ADOLC_MATH_NSP::sinh(a.val);
1412-
for (int l = 0; l < adouble::numDir; l++) {
1413-
for (int k = 0; k < adouble::degree; k++) {
1413+
for (size_t l = 0; l < adouble::numDir; l++) {
1414+
for (size_t k = 0; k < adouble::degree; k++) {
14141415
// ho_deriv[k][l]
14151416
m = k + 1;
14161417
sum1 = tmp2.val * m * a.ho_deriv[k][l];
14171418
sum2 = tmp.val * m * a.ho_deriv[k][l];
14181419
i = k - 1;
1419-
for (int j = 0; j < k; j++) {
1420+
for (size_t j = 0; j < k; j++) {
14201421
sum1 += (j + 1) * a.ho_deriv[j][l] * tmp2.ho_deriv[i - j][l];
14211422
sum2 += (j + 1) * a.ho_deriv[j][l] * tmp.ho_deriv[i - j][l];
14221423
}
@@ -1577,14 +1578,14 @@ inline adouble fabs(const adouble &a) {
15771578
// coefficient
15781579

15791580
int *leading_sgn = (int *)alloca(sizeof(int) * adouble::degree);
1580-
for (int l = 0; l < adouble::numDir; l++) // Init
1581+
for (size_t l = 0; l < adouble::numDir; l++) // Init
15811582
{
15821583
leading_sgn[l] = 1;
15831584
}
15841585
bool found;
15851586

1586-
for (int l = 0; l < adouble::numDir; l++) {
1587-
for (int k = 0; k < adouble::degree; k++) {
1587+
for (size_t l = 0; l < adouble::numDir; l++) {
1588+
for (size_t k = 0; k < adouble::degree; k++) {
15881589
if (tmp.ho_deriv[k][l] > 0 && (!found)) {
15891590
leading_sgn[l] = 1;
15901591
found = true;
@@ -1611,8 +1612,8 @@ inline adouble fabs(const adouble &a) {
16111612

16121613
// assume we found all leading Taylor coefficients
16131614

1614-
for (int l = 0; l < adouble::numDir; l++) {
1615-
for (int k = 0; k < adouble::degree; k++) {
1615+
for (size_t l = 0; l < adouble::numDir; l++) {
1616+
for (size_t k = 0; k < adouble::degree; k++) {
16161617
tmp.ho_deriv[k][l] *= leading_sgn[l];
16171618
// TODO do not forget zero-th Taylor coefficient
16181619
}

0 commit comments

Comments
 (0)