Changeset 2b06a0b2 in subsurface


Ignore:
Timestamp:
Mar 9, 2017, 8:07:30 AM (3 months ago)
Author:
Jeremie Guichard <djebrest@…>
Branches:
master
Children:
0828427
Parents:
406e428
Message:

Fix potential double/float to int rounding errors

Not using lrint(f) when converting double/float to int
creates rounding errors.
This error was detected by TestParse::testParseDM4 failure
on Windows. It was creating rounding inconsistencies
on Linux too, see change in TestDiveDM4.xml.

Enable -Wfloat-conversion for gcc version greater than 4.9.0

Signed-off-by: Jeremie Guichard <djebrest@…>

Files:
20 edited

Legend:

Unmodified
Added
Removed
  • CMakeLists.txt

    r7b08f8d r2b06a0b2  
    8787        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=gnu99")
    8888        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
     89
     90        # Warn about possible float conversion errors
     91        # Use NOT VERSION_LESS since VERSION_GREATER_EQUAL is not available
     92        # in currently used cmake version.
     93        if (NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS "4.9.0")
     94                set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wfloat-conversion")
     95        endif()
     96
    8997elseif ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Intel")
    9098  # using Intel C++
  • core/cochran.c

    r7be962b r2b06a0b2  
    579579                *avg_depth = (*avg_depth * seconds + depth) / (seconds + 1);
    580580
    581                 sample->depth.mm = depth * FEET * 1000;
     581                sample->depth.mm = lrint(depth * FEET * 1000);
    582582                sample->ndl.seconds = ndl;
    583583                sample->in_deco = in_deco;
    584584                sample->stoptime.seconds = deco_time;
    585                 sample->stopdepth.mm = deco_ceiling * FEET * 1000;
     585                sample->stopdepth.mm = lrint(deco_ceiling * FEET * 1000);
    586586                sample->temperature.mkelvin = C_to_mkelvin((temp - 32) / 1.8);
    587587                sample->sensor = 0;
    588                 sample->cylinderpressure.mbar = psi * PSI / 100;
     588                sample->cylinderpressure.mbar = lrint(psi * PSI / 100);
    589589
    590590                finish_sample(dc);
     
    694694                dc->duration.seconds = (log[CMD_BT] + log[CMD_BT + 1] * 256) * 60;
    695695                dc->surfacetime.seconds = (log[CMD_SIT] + log[CMD_SIT + 1] * 256) * 60;
    696                 dc->maxdepth.mm = (log[CMD_MAX_DEPTH] +
    697                         log[CMD_MAX_DEPTH + 1] * 256) / 4 * FEET * 1000;
    698                 dc->meandepth.mm = (log[CMD_AVG_DEPTH] +
    699                         log[CMD_AVG_DEPTH + 1] * 256) / 4 * FEET * 1000;
     696                dc->maxdepth.mm = lrint((log[CMD_MAX_DEPTH] +
     697                        log[CMD_MAX_DEPTH + 1] * 256) / 4 * FEET * 1000);
     698                dc->meandepth.mm = lrint((log[CMD_AVG_DEPTH] +
     699                        log[CMD_AVG_DEPTH + 1] * 256) / 4 * FEET * 1000);
    700700                dc->watertemp.mkelvin = C_to_mkelvin((log[CMD_MIN_TEMP] / 32) - 1.8);
    701                 dc->surface_pressure.mbar = ATM / BAR * pow(1 - 0.0000225577
    702                         * (double) log[CMD_ALTITUDE] * 250 * FEET, 5.25588) * 1000;
     701                dc->surface_pressure.mbar = lrint(ATM / BAR * pow(1 - 0.0000225577
     702                        * (double) log[CMD_ALTITUDE] * 250 * FEET, 5.25588) * 1000);
    703703                dc->salinity = 10000 + 150 * log[CMD_WATER_CONDUCTIVITY];
    704704
     
    735735                dc->duration.seconds = (log[EMC_BT] + log[EMC_BT + 1] * 256) * 60;
    736736                dc->surfacetime.seconds = (log[EMC_SIT] + log[EMC_SIT + 1] * 256) * 60;
    737                 dc->maxdepth.mm = (log[EMC_MAX_DEPTH] +
    738                         log[EMC_MAX_DEPTH + 1] * 256) / 4 * FEET * 1000;
    739                 dc->meandepth.mm = (log[EMC_AVG_DEPTH] +
    740                         log[EMC_AVG_DEPTH + 1] * 256) / 4 * FEET * 1000;
     737                dc->maxdepth.mm = lrint((log[EMC_MAX_DEPTH] +
     738                        log[EMC_MAX_DEPTH + 1] * 256) / 4 * FEET * 1000);
     739                dc->meandepth.mm = lrint((log[EMC_AVG_DEPTH] +
     740                        log[EMC_AVG_DEPTH + 1] * 256) / 4 * FEET * 1000);
    741741                dc->watertemp.mkelvin = C_to_mkelvin((log[EMC_MIN_TEMP] - 32) / 1.8);
    742                 dc->surface_pressure.mbar = ATM / BAR * pow(1 - 0.0000225577
    743                         * (double) log[EMC_ALTITUDE] * 250 * FEET, 5.25588) * 1000;
     742                dc->surface_pressure.mbar = lrint(ATM / BAR * pow(1 - 0.0000225577
     743                        * (double) log[EMC_ALTITUDE] * 250 * FEET, 5.25588) * 1000);
    744744                dc->salinity = 10000 + 150 * (log[EMC_WATER_CONDUCTIVITY] & 0x3);
    745745
     
    759759        // Check for corrupt dive
    760760        if (corrupt_dive) {
    761                 dc->maxdepth.mm = max_depth * FEET * 1000;
    762                 dc->meandepth.mm = avg_depth * FEET * 1000;
     761                dc->maxdepth.mm = lrint(max_depth * FEET * 1000);
     762                dc->meandepth.mm = lrint(avg_depth * FEET * 1000);
    763763                dc->watertemp.mkelvin = C_to_mkelvin((min_temp - 32) / 1.8);
    764764                dc->duration.seconds = duration;
  • core/datatrak.c

    rfccfb96 r2b06a0b2  
    385385        read_bytes(2);
    386386        if (tmp_2bytes != 0x7FFF && dt_dive->cylinder[0].type.size.mliter)
    387                 dt_dive->cylinder[0].gas_used.mliter = dt_dive->cylinder[0].type.size.mliter * (tmp_2bytes / 100.0);
     387                dt_dive->cylinder[0].gas_used.mliter = lrint(dt_dive->cylinder[0].type.size.mliter * (tmp_2bytes / 100.0));
    388388
    389389        /*
     
    626626                        if (is_nitrox) {
    627627                                dt_dive->cylinder[0].gasmix.o2.permille =
    628                                         (tmp_1byte & 0x0F ? 20.0 + 2 * (tmp_1byte & 0x0F) : 21.0) * 10;
     628                                        lrint((tmp_1byte & 0x0F ? 20.0 + 2 * (tmp_1byte & 0x0F) : 21.0) * 10);
    629629                        } else {
    630630                                dt_dive->cylinder[0].gasmix.o2.permille = tmp_1byte * 10;
  • core/deco.c

    rbd89e33e r2b06a0b2  
    623623        pressure_delta = tissues_tolerance > surface_pressure ? tissues_tolerance - surface_pressure : 0.0;
    624624
    625         depth = rel_mbar_to_depth(pressure_delta * 1000, dive);
     625        depth = rel_mbar_to_depth(lrint(pressure_delta * 1000), dive);
    626626
    627627        if (!smooth)
    628                 depth = ceil(depth / DECO_STOPS_MULTIPLIER_MM) * DECO_STOPS_MULTIPLIER_MM;
     628                depth = lrint(ceil(depth / DECO_STOPS_MULTIPLIER_MM) * DECO_STOPS_MULTIPLIER_MM);
    629629
    630630        if (depth > 0 && depth < buehlmann_config.last_deco_stop_in_mtr * 1000)
  • core/device.c

    rc809a887 r2b06a0b2  
    6565{
    6666        double t_frac = max_t * (1 - avg_d / (double)max_d);
    67         int t1 = max_d / slope;
    68         int t4 = max_t - t1 * d_frac;
    69         int t3 = t4 - (t_frac - t1) / (1 - d_frac);
    70         int t2 = t3 - t1 * (1 - d_frac);
     67        int t1 = lrint(max_d / slope);
     68        int t4 = lrint(max_t - t1 * d_frac);
     69        int t3 = lrint(t4 - (t_frac - t1) / (1 - d_frac));
     70        int t2 = lrint(t3 - t1 * (1 - d_frac));
    7171
    7272        if (t1 < 0 || t1 > t2 || t2 > t3 || t3 > t4 || t4 > max_t)
     
    7878        s[2].depth.mm = max_d;
    7979        s[3].time.seconds = t3;
    80         s[3].depth.mm = max_d * d_frac;
     80        s[3].depth.mm = lrint(max_d * d_frac);
    8181        s[4].time.seconds = t4;
    82         s[4].depth.mm = max_d * d_frac;
     82        s[4].depth.mm = lrint(max_d * d_frac);
    8383
    8484        return 1;
     
    9393        // shallow or short dives are just trapecoids based on the given slope
    9494        if (max_d < 10000 || max_t < 600) {
    95                 s[1].time.seconds = max_d / slope;
     95                s[1].time.seconds = lrint(max_d / slope);
    9696                s[1].depth.mm = max_d;
    97                 s[2].time.seconds = max_t - max_d / slope;
     97                s[2].time.seconds = max_t - lrint(max_d / slope);
    9898                s[2].depth.mm = max_d;
    9999        } else {
    100                 s[1].time.seconds = max_d / slope;
     100                s[1].time.seconds = lrint(max_d / slope);
    101101                s[1].depth.mm = max_d;
    102                 s[2].time.seconds = max_t - max_d / slope - 180;
     102                s[2].time.seconds = max_t - lrint(max_d / slope) - 180;
    103103                s[2].depth.mm = max_d;
    104                 s[3].time.seconds = max_t - 5000 / slope - 180;
     104                s[3].time.seconds = max_t - lrint(5000 / slope) - 180;
    105105                s[3].depth.mm = 5000;
    106                 s[4].time.seconds = max_t - 5000 / slope;
     106                s[4].time.seconds = max_t - lrint(5000 / slope);
    107107                s[4].depth.mm = 5000;
    108108        }
  • core/dive.h

    r406e428 r2b06a0b2  
    500500        ppo2n2.mbar = depth_to_mbar(end.mm, dive);
    501501
    502         double maxambient = ppo2n2.mbar / (1 - get_he(mix) / 1000.0);
     502        int maxambient = lrint(ppo2n2.mbar / (1 - get_he(mix) / 1000.0));
    503503        rounded_depth.mm = lrint(((double)mbar_to_depth(maxambient, dive)) / roundto) * roundto;
    504504        return rounded_depth;
  • core/divelist.c

    r406e428 r2b06a0b2  
    179179                } else {
    180180                        int o2 = active_o2(dive, dc, sample->time);
    181                         po2 = o2 * depth_to_atm(sample->depth.mm, dive);
     181                        po2 = lrint(o2 * depth_to_atm(sample->depth.mm, dive));
    182182                }
    183183                if (po2 >= 500)
     
    244244                } else {
    245245                        int o2 = active_o2(dive, dc, sample->time);
    246                         po2 = o2 * depth_to_atm(sample->depth.mm, dive);
     246                        po2 = lrint(o2 * depth_to_atm(sample->depth.mm, dive));
    247247                }
    248248                /* CNS don't increse when below 500 matm */
     
    257257        }
    258258        /* save calculated cns in dive struct */
    259         dive->cns = cns;
     259        dive->cns = lrint(cns);
    260260        return dive->cns;
    261261}
     
    306306
    307307        /* milliliters per minute.. */
    308         return sac * 1000;
     308        return lrint(sac * 1000);
    309309}
    310310
  • core/divesite.c

    r2e77a22e r2b06a0b2  
    6666
    6767        // Earth radious in metres
    68         return 6371000 * c;
     68        return lrint(6371000 * c);
    6969}
    7070
  • core/file.c

    r9006802 r2b06a0b2  
    294294                break;
    295295        case POSEIDON_DEPTH:
    296                 sample->depth.mm = val * 0.5 *1000;
     296                sample->depth.mm = lrint(val * 0.5 * 1000);
    297297                break;
    298298        case POSEIDON_TEMP:
     
    300300                break;
    301301        case POSEIDON_SETPOINT:
    302                 sample->setpoint.mbar = val * 10;
     302                sample->setpoint.mbar = lrint(val * 10);
    303303                break;
    304304        case POSEIDON_SENSOR1:
    305                 sample->o2sensor[0].mbar = val * 10;
     305                sample->o2sensor[0].mbar = lrint(val * 10);
    306306                break;
    307307        case POSEIDON_SENSOR2:
    308                 sample->o2sensor[1].mbar = val * 10;
     308                sample->o2sensor[1].mbar = lrint(val * 10);
    309309                break;
    310310        case POSEIDON_PRESSURE:
    311                 sample->cylinderpressure.mbar = val * 1000;
     311                sample->cylinderpressure.mbar = lrint(val * 1000);
    312312                break;
    313313        case POSEIDON_O2CYLINDER:
    314                 sample->o2cylinderpressure.mbar = val * 1000;
     314                sample->o2cylinderpressure.mbar = lrint(val * 1000);
    315315                break;
    316316        case POSEIDON_NDL:
    317                 sample->ndl.seconds = val * 60;
     317                sample->ndl.seconds = lrint(val * 60);
    318318                break;
    319319        case POSEIDON_CEILING:
    320                 sample->stopdepth.mm = val * 1000;
     320                sample->stopdepth.mm = lrint(val * 1000);
    321321                break;
    322322        }
  • core/gaspressures.c

    r406e428 r2b06a0b2  
    138138                                pressure = start;
    139139                                if (pt_sum)
    140                                         pressure -= (start - end) * (double)pt / pt_sum;
     140                                        pressure -= lrint((start - end) * (double)pt / pt_sum);
    141141                                list->end = pressure;
    142142                                if (list == tmp)
  • core/libdivecomputer.c

    r406e428 r2b06a0b2  
    167167                                                 * Then we can round the wet sizes so we get to multiples of 10
    168168                                                 * for cuft sizes (as that's all that you can enter) */
    169                                                 dive->cylinder[i].type.workingpressure.mbar *= 206.843 / 206.7;
     169                                                dive->cylinder[i].type.workingpressure.mbar = lrint(
     170                                                        dive->cylinder[i].type.workingpressure.mbar * 206.843 / 206.7 );
    170171                                                char name_buffer[9];
    171                                                 int rounded_size = ml_to_cuft(gas_volume(&dive->cylinder[i],
    172                                                                                          dive->cylinder[i].type.workingpressure));
     172                                                int rounded_size = lrint(ml_to_cuft(gas_volume(&dive->cylinder[i],
     173                                                        dive->cylinder[i].type.workingpressure)));
    173174                                                rounded_size = (int)((rounded_size + 5) / 10) * 10;
    174175                                                switch (dive->cylinder[i].type.workingpressure.mbar) {
     
    190191                                                }
    191192                                                dive->cylinder[i].type.description = copy_string(name_buffer);
    192                                                 dive->cylinder[i].type.size.mliter = cuft_to_l(rounded_size) * 1000 /
    193                                                                                      mbar_to_atm(dive->cylinder[i].type.workingpressure.mbar);
     193                                                dive->cylinder[i].type.size.mliter = lrint(cuft_to_l(rounded_size) * 1000 /
     194                                                                                        mbar_to_atm(dive->cylinder[i].type.workingpressure.mbar));
    194195                                        }
    195196                                }
     
    204205                        // this new API also gives us the beginning and end pressure for the tank
    205206                        if (!IS_FP_SAME(tank.beginpressure, 0.0) && !IS_FP_SAME(tank.endpressure, 0.0)) {
    206                                 dive->cylinder[i].start.mbar = tank.beginpressure * 1000;
    207                                 dive->cylinder[i].end.mbar = tank.endpressure * 1000;
     207                                dive->cylinder[i].start.mbar = lrint(tank.beginpressure * 1000);
     208                                dive->cylinder[i].end.mbar = lrint(tank.endpressure * 1000);
    208209                        }
    209210                }
  • core/liquivision.c

    r7be962b r2b06a0b2  
    235235                        start_cns = *(float *) (buf + ptr);
    236236                        ptr += 4;
    237                         dive->cns = *(float *) (buf + ptr);     // end cns
     237                        dive->cns = lrintf(*(float *) (buf + ptr));     // end cns
    238238                        ptr += 4;
    239                         dive->otu = *(float *) (buf + ptr);
     239                        dive->otu = lrintf(*(float *) (buf + ptr));
    240240                        ptr += 4;
    241241                        dive_mode = *(buf + ptr++);     // 0=Deco, 1=Gauge, 2=None
  • core/parse-xml.c

    r406e428 r2b06a0b2  
    426426                switch (xml_parsing_units.temperature) {
    427427                case KELVIN:
    428                         temperature->mkelvin = val.fp * 1000;
     428                        temperature->mkelvin = lrint(val.fp * 1000);
    429429                        break;
    430430                case CELSIUS:
     
    22202220                        cur_dive->cylinder[cur_cylinder_index].type.size.mliter = 12000;
    22212221                else
    2222                         cur_dive->cylinder[cur_cylinder_index].type.size.mliter = (atof(data[6])) * 1000;
     2222                        cur_dive->cylinder[cur_cylinder_index].type.size.mliter = lrint((atof(data[6])) * 1000);
    22232223        }
    22242224        if (data[2])
     
    22412241        if (data[1]) {
    22422242                strcpy(cur_event.name, "gaschange");
    2243                 cur_event.value = atof(data[1]);
     2243                cur_event.value = lrint(atof(data[1]));
    22442244        }
    22452245        event_end();
     
    23092309
    23102310        if (data[6])
    2311                 cur_dive->dc.maxdepth.mm = atof(data[6]) * 1000;
     2311                cur_dive->dc.maxdepth.mm = lrint(atof(data[6]) * 1000);
    23122312        if (data[8])
    23132313                cur_dive->dc.airtemp.mkelvin = C_to_mkelvin(atoi(data[8]));
     
    23282328                cur_dive->cylinder[cur_cylinder_index].end.mbar = (atoi(data[11]));
    23292329        if (data[12])
    2330                 cur_dive->cylinder[cur_cylinder_index].type.size.mliter = (atof(data[12])) * 1000;
     2330                cur_dive->cylinder[cur_cylinder_index].type.size.mliter = lrint((atof(data[12])) * 1000);
    23312331        if (data[13])
    23322332                cur_dive->cylinder[cur_cylinder_index].type.workingpressure.mbar = (atoi(data[13]));
     
    23482348                cur_sample->time.seconds = i * interval;
    23492349                if (profileBlob)
    2350                         cur_sample->depth.mm = profileBlob[i] * 1000;
     2350                        cur_sample->depth.mm = lrintf(profileBlob[i] * 1000.0f);
    23512351                else
    23522352                        cur_sample->depth.mm = cur_dive->dc.maxdepth.mm;
     
    24322432
    24332433        if (data[6])
    2434                 cur_dive->dc.maxdepth.mm = atof(data[6]) * 1000;
     2434                cur_dive->dc.maxdepth.mm = lrint(atof(data[6]) * 1000);
    24352435        if (data[8])
    24362436                cur_dive->dc.airtemp.mkelvin = C_to_mkelvin(atoi(data[8]));
     
    24782478                sample_start();
    24792479                cur_sample->time.seconds = i * interval;
    2480                 cur_sample->depth.mm = depth[0] * 1000;
     2480                cur_sample->depth.mm = lrintf(depth[0] * 1000.0f);
    24812481                /*
    24822482                 * Limit temperatures and cylinder pressures to somewhat
     
    25072507                        cur_sample->time.seconds = i * interval;
    25082508                        if (profileBlob)
    2509                                 cur_sample->depth.mm = profileBlob[i] * 1000;
     2509                                cur_sample->depth.mm = lrintf(profileBlob[i] * 1000.0f);
    25102510                        else
    25112511                                cur_sample->depth.mm = cur_dive->dc.maxdepth.mm;
     
    26022602        cylinder_start();
    26032603        if (data[0])
    2604                 cur_dive->cylinder[cur_cylinder_index].gasmix.o2.permille = atof(data[0]) * 1000;
     2604                cur_dive->cylinder[cur_cylinder_index].gasmix.o2.permille = lrint(atof(data[0]) * 1000);
    26052605        if (data[1])
    2606                 cur_dive->cylinder[cur_cylinder_index].gasmix.he.permille = atof(data[1]) * 1000;
     2606                cur_dive->cylinder[cur_cylinder_index].gasmix.he.permille = lrint(atof(data[1]) * 1000);
    26072607        cylinder_end();
    26082608
     
    26212621        if (data[1]) {
    26222622                strcpy(cur_event.name, "gaschange");
    2623                 cur_event.value = atof(data[1]) * 100;
     2623                cur_event.value = lrint(atof(data[1]) * 100);
    26242624        }
    26252625        event_end();
     
    26582658                cur_sample->time.seconds = atoi(data[0]);
    26592659        if (data[1])
    2660                 cur_sample->depth.mm = metric ? atof(data[1]) * 1000 : feet_to_mm(atof(data[1]));
     2660                cur_sample->depth.mm = metric ? lrint(atof(data[1]) * 1000) : feet_to_mm(atof(data[1]));
    26612661        if (data[2])
    26622662                cur_sample->temperature.mkelvin = metric ? C_to_mkelvin(atof(data[2])) : F_to_mkelvin(atof(data[2]));
    26632663        if (data[3]) {
    2664                 cur_sample->setpoint.mbar = atof(data[3]) * 1000;
     2664                cur_sample->setpoint.mbar = lrint(atof(data[3]) * 1000);
    26652665                cur_dive->dc.divemode = CCR;
    26662666        }
     
    27112711        /* TODO: verify that metric calculation is correct */
    27122712        if (data[6])
    2713                 cur_dive->dc.maxdepth.mm = metric ? atof(data[6]) * 1000 : feet_to_mm(atof(data[6]));
     2713                cur_dive->dc.maxdepth.mm = metric ? lrint(atof(data[6]) * 1000) : feet_to_mm(atof(data[6]));
    27142714
    27152715        if (data[7])
     
    32953295
    32963296        if (data[5])
    3297                 cur_dive->dc.maxdepth.mm = atof(data[5]) * 1000;
     3297                cur_dive->dc.maxdepth.mm = lrint(atof(data[5]) * 1000);
    32983298
    32993299        if (data[6])
  • core/planner.c

    r406e428 r2b06a0b2  
    221221                cyl->type.workingpressure.mbar = psi_to_mbar(ti->psi);
    222222                if (ti->psi)
    223                         cyl->type.size.mliter = cuft_to_l(ti->cuft) * 1000 / bar_to_atm(psi_to_bar(ti->psi));
     223                        cyl->type.size.mliter = lrint(cuft_to_l(ti->cuft) * 1000 / bar_to_atm(psi_to_bar(ti->psi)));
    224224        }
    225225        // MOD of air
     
    242242                return;
    243243        mean_depth.mm = (old_depth + new_depth) / 2;
    244         gas_used.mliter = depth_to_atm(mean_depth.mm, d) * sac / 60 * duration * factor / 1000;
     244        gas_used.mliter = lrint(depth_to_atm(mean_depth.mm, d) * sac / 60 * duration * factor / 1000);
    245245        cyl->gas_used.mliter += gas_used.mliter;
    246246        if (in_deco)
    247247                cyl->deco_gas_used.mliter += gas_used.mliter;
    248248        if (cyl->type.size.mliter) {
    249                 delta_p.mbar = gas_used.mliter * 1000.0 / cyl->type.size.mliter * gas_compressibility_factor(&cyl->gasmix, cyl->end.mbar / 1000.0);
     249                delta_p.mbar = lrint(gas_used.mliter * 1000.0 / cyl->type.size.mliter * gas_compressibility_factor(&cyl->gasmix, cyl->end.mbar / 1000.0));
    250250                cyl->end.mbar -= delta_p.mbar;
    251251        }
     
    831831
    832832        /* Get SAC values and units for printing it in gas consumption */
    833         float bottomsacvalue, decosacvalue;
     833        double bottomsacvalue, decosacvalue;
    834834        int sacdecimals;
    835835        const char* sacunit;
     
    859859                deco_volume = get_volume_units(cyl->deco_gas_used.mliter, NULL, &unit);
    860860                if (cyl->type.size.mliter) {
    861                         int remaining_gas = (double)cyl->end.mbar * cyl->type.size.mliter / 1000.0 / gas_compressibility_factor(&cyl->gasmix, cyl->end.mbar / 1000.0);
     861                        int remaining_gas = lrint((double)cyl->end.mbar * cyl->type.size.mliter / 1000.0 / gas_compressibility_factor(&cyl->gasmix, cyl->end.mbar / 1000.0));
    862862                        double deco_pressure_bar = isothermal_pressure(&cyl->gasmix, 1.0, remaining_gas + cyl->deco_gas_used.mliter, cyl->type.size.mliter)
    863863                                        - cyl->end.mbar / 1000.0;
    864                         deco_pressure = get_pressure_units(1000.0 * deco_pressure_bar, &pressure_unit);
     864                        deco_pressure = get_pressure_units(lrint(1000.0 * deco_pressure_bar), &pressure_unit);
    865865                        pressure = get_pressure_units(cyl->start.mbar - cyl->end.mbar, &pressure_unit);
    866866                        /* Warn if the plan uses more gas than is available in a cylinder
  • core/profile.c

    r406e428 r2b06a0b2  
    113113                md = MAX((unsigned)30000, ROUND_UP(mm + 3000, 10000));
    114114        }
    115         md += pi->maxpp * 9000;
     115        md += lrint(pi->maxpp * 9000);
    116116        return md;
    117117}
     
    195195
    196196        /* milliliters per minute */
    197         return airuse / atm * 60 / duration;
     197        return lrint(airuse / atm * 60 / duration);
    198198}
    199199
     
    10211021                                entry->ceilings[j] = deco_allowed_depth(tolerated_by_tissue[j], surface_pressure, dive, 1);
    10221022                                entry->percentages[j] = tissue_inertgas_saturation[j] < entry->ambpressure ?
    1023                                                                 tissue_inertgas_saturation[j] / entry->ambpressure * AMB_PERCENTAGE :
    1024                                                                 AMB_PERCENTAGE + (tissue_inertgas_saturation[j] - entry->ambpressure) / (m_value - entry->ambpressure) * (100.0 - AMB_PERCENTAGE);
     1023                                        lrint(tissue_inertgas_saturation[j] / entry->ambpressure * AMB_PERCENTAGE) :
     1024                                        lrint(AMB_PERCENTAGE + (tissue_inertgas_saturation[j] - entry->ambpressure) / (m_value - entry->ambpressure) * (100.0 - AMB_PERCENTAGE));
    10251025                        }
    10261026
     
    13231323                put_format(b, translate("gettextFromC", "pHe: %.2fbar\n"), entry->pressures.he);
    13241324        if (prefs.mod) {
    1325                 mod = (int)get_depth_units(entry->mod, NULL, &depth_unit);
     1325                mod = lrint(get_depth_units(lrint(entry->mod), NULL, &depth_unit));
    13261326                put_format(b, translate("gettextFromC", "MOD: %d%s\n"), mod, depth_unit);
    13271327        }
    1328         eadd = (int)get_depth_units(entry->eadd, NULL, &depth_unit);
     1328        eadd = lrint(get_depth_units(lrint(entry->eadd), NULL, &depth_unit));
    13291329        if (prefs.ead) {
    13301330                switch (pi->dive_type) {
    13311331                case NITROX:
    1332                         ead = (int)get_depth_units(entry->ead, NULL, &depth_unit);
     1332                        ead = lrint(get_depth_units(lrint(entry->ead), NULL, &depth_unit));
    13331333                        put_format(b, translate("gettextFromC", "EAD: %d%s\nEADD: %d%s\n"), ead, depth_unit, eadd, depth_unit);
    13341334                        break;
    13351335                case TRIMIX:
    1336                         end = (int)get_depth_units(entry->end, NULL, &depth_unit);
     1336                        end = lrint(get_depth_units(lrint(entry->end), NULL, &depth_unit));
    13371337                        put_format(b, translate("gettextFromC", "END: %d%s\nEADD: %d%s\n"), end, depth_unit, eadd, depth_unit);
    13381338                        break;
     
    15711571
    15721572                        /* milliliters per minute */
    1573                         int sac = volume_used / atm * 60 / delta_time;
     1573                        int sac = lrint(volume_used / atm * 60 / delta_time);
    15741574                        memcpy(buf2, buf, bufsize);
    15751575                        volume_value = get_volume_units(sac, &volume_precision, &volume_unit);
  • core/save-html.c

    r84166a4 r2b06a0b2  
    128128                        int volume = cylinder->type.size.mliter;
    129129                        if (prefs.units.volume == CUFT && cylinder->type.workingpressure.mbar)
    130                                 volume *= bar_to_atm(cylinder->type.workingpressure.mbar / 1000.0);
     130                                volume = lrint(volume * bar_to_atm(cylinder->type.workingpressure.mbar / 1000.0));
    131131                        put_HTML_volume_units(b, volume, "\"Size\":\"", " \", ");
    132132                } else {
  • core/statistics.c

    r406e428 r2b06a0b2  
    6969        if (dp->meandepth.mm) {
    7070                stats->total_average_depth_time.seconds += duration;
    71                 stats->avg_depth.mm = (1.0 * old_tadt * stats->avg_depth.mm +
    72                                        duration * dp->meandepth.mm) /
    73                                 stats->total_average_depth_time.seconds;
     71                stats->avg_depth.mm = lrint((1.0 * old_tadt * stats->avg_depth.mm +
     72                                        duration * dp->meandepth.mm) /
     73                                        stats->total_average_depth_time.seconds);
    7474        }
    7575        if (dp->sac > 100) { /* less than .1 l/min is bogus, even with a pSCR */
    7676                sac_time = stats->total_sac_time + duration;
    77                 stats->avg_sac.mliter = (1.0 * stats->total_sac_time * stats->avg_sac.mliter +
     77                stats->avg_sac.mliter = lrint((1.0 * stats->total_sac_time * stats->avg_sac.mliter +
    7878                                         duration * dp->sac) /
    79                                         sac_time;
     79                                         sac_time);
    8080                if (dp->sac > stats->max_sac.mliter)
    8181                        stats->max_sac.mliter = dp->sac;
  • core/uemis-downloader.c

    r406e428 r2b06a0b2  
    130130{
    131131        weight->weight.grams = uemis_get_weight_unit(diveid) ?
    132                                        lbs_to_grams(ascii_strtod(buffer, NULL)) :
    133                                        ascii_strtod(buffer, NULL) * 1000;
     132                lbs_to_grams(ascii_strtod(buffer, NULL)) :
     133                lrint(ascii_strtod(buffer, NULL) * 1000);
    134134        weight->description = strdup(translate("gettextFromC", "unknown"));
    135135}
  • core/uemis.c

    r406e428 r2b06a0b2  
    174174                        if (ds) {
    175175                                ds->name = strdup(text);
    176                                 ds->longitude.udeg = round(longitude * 1000000);
    177                                 ds->latitude.udeg = round(latitude * 1000000);
     176                                ds->longitude.udeg = lrint(longitude * 1000000);
     177                                ds->latitude.udeg = lrint(latitude * 1000000);
    178178                        }
    179179                }
     
    330330                template = 1;
    331331        for (i = 0; i < template; i++) {
    332                 float volume = *(float *)(data + 116 + 25 * (gasoffset + i)) * 1000.0;
     332                float volume = *(float *)(data + 116 + 25 * (gasoffset + i)) * 1000.0f;
    333333                /* uemis always assumes a working pressure of 202.6bar (!?!?) - I first thought
    334334                 * it was 3000psi, but testing against all my dives gets me that strange number.
  • dives/TestDiveDM4.xml

    r4c74b15 r2b06a0b2  
    142142  <sample time='42:20 min' depth='15.95 m' pressure='90.42 bar' />
    143143  <sample time='42:40 min' depth='16.24 m' pressure='89.9 bar' />
    144   <sample time='43:00 min' depth='16.379 m' pressure='88.92 bar' />
     144  <sample time='43:00 min' depth='16.38 m' pressure='88.92 bar' />
    145145  <sample time='43:20 min' depth='16.67 m' pressure='88.2 bar' />
    146146  <sample time='43:40 min' depth='16.61 m' pressure='87.41 bar' />
Note: See TracChangeset for help on using the changeset viewer.