Как я могу доверять приведению от двойного к целому?

В комментариях вы говорите, что хотите Integer part of the result. Что ж, к сожалению, результатом double 1.2 / 0.4 оказывается 2.9999999999999996 (на моей машине вы можете увидеть точное значение cout, используя std::setprecision), и поэтому целая часть результата равна 2. Это, как вы знаете, связано с тем, что не все числа могут быть представлены числами с плавающей запятой, и потому, что операции с плавающей запятой вызывают ошибки.

Взятие целой части числа с плавающей запятой находится на том же уровне, что и сравнение чисел с плавающей запятой с равенством; Вы не получите стабильных результатов. Если вам нужны точные результаты, общее решение состоит в том, чтобы вообще не использовать числа с плавающей запятой, а вместо этого использовать числа с фиксированной запятой.

Как и в случае сравнения на равенство, вы можете обойти эту проблему с помощью соответствующего значения epsilon. В этом случае вы можете добавить (или вычесть, если отрицательный) очень маленькое число с плавающей запятой к результату, прежде чем брать целую часть. Добавленное число должно быть больше, чем наибольшая возможная ошибка, которую может иметь число, но меньше, чем наименьшее число точности, которое вы должны поддерживать (чтобы 9,999 не стало 10, если вы должны поддерживать точность до 0,001). Вычислить хорошее число для этого может быть довольно сложно.

Я основываю это более или менее на некоторых ваших комментариях другим. Чтобы получить целую часть, решение состоит в том, чтобы использовать modf. Но целая часть 1.2 / 0.4 вполне может быть 2, а не 3; 0.4 не может быть представлено в машинных числах с плавающей запятой (по крайней мере, большинство из них), поэтому вы делите на что-то очень близкое к 0.4.

Главный вопрос в том, чего вы на самом деле хотите. Если вы хотите дискреционно (существует ли такое слово) в зависимости от bucketSize, то правильный способ сделать это - использовать масштабированные целые числа повсюду:

int value = 12;
int bucketSize = 4;
int bucketId = value / bucketSize;

а потом:

std::cout << "bucketId as double: " << bucketId / 10.0 << std::endl;
std::cout << "bucketId as int: " << bucketId / 10 << std::endl;

В противном случае, если вы хотите сохранить значения как двойные, вам придется решить, насколько близко близко для преобразования в int, а затем использовать свою собственную функцию:

int
asInt( double d )
{
    double results;
    double frac = modf( d, &results );
    if ( frac > 1.0 - yourEpsilonHere ) {
        results += 1.0;
    }
    return results;
}

Вам решать, какое значение подходит для yourEpsilonHere; это зависит от приложения. (Один раз, когда я использовал эту технику, мы использовали 1E-9. Однако это не означает, что она подходит для вас.)

Используйте 1_. Он возвращает ближайшее целое число к вашему двойному числу.

#include<numeric>
double value = 1.2;
double bucketSize = 0.4;
double bucketId = value / bucketSize;

std::cout << "bucketId as int: " << std::lround(bucketId) << std::endl;

Обратите внимание, что 3.0/2.0 по-прежнему может привести к неожиданным результатам, в зависимости от того, является ли результат 1.4999998 или 1.5000001, наивно произнесенным.

Может быть, фиксированная десятичная аппроксимация?

(int)(value * 100)/(int)(bucketSize *100)

Если вы хотите, чтобы 0,25 перед возвратом следующего числа (например, от (double)1.75 до (int)2) использовали int(floor(buckedId+0.25)).

Дело в том, насколько сильно вы хотите округлить до предыдущего числа.

#include<iostream>
#include <limits>
int main()
{
    double value = 1.200000000000000;
    double bucketSize = 0.4000000000000000;
    double bucketId = value / bucketSize;
    std::cout.precision(16);
    std::cout << "bucketId as double: " <<  std::fixed << bucketId << std::endl;
    std::cout << "bucketId as int: " << int(bucketId) << std::endl;
    return 1;
}

попробуйте это в своей системе, вы хотели бы что-то вроде

ведроId как двойной: 2.9999999999999996

ведроId как целое: 2

и чем с

std::cout.precision(15);

ты бы

ведроId как двойной: 3.000000000000000

ведроId как целое: 2

это происходит из-за того, что предел точности double равен 15 , вы также можете попробовать спроектировать с помощью long double и изменить точность.

Я бы предложил что-то вроде

double d = 1.4 / 0.4;
int whole = (int)d;
int nextWhole = whole + 1;

int result = whole;

if (fabs(d - nextWhole) < EPSILON) result = nextWhole;

(это работает для положительных чисел)

По сути, если ваше число настолько близко к следующему целому числу, что это не имеет значения, этот код будет использовать следующее целое число.

Вы можете использовать round()

http://www.cplusplus.com/reference/cmath/round/

Я считаю, что это всегда отнимает 0,5 числа от нуля, поэтому, если это плохо для вашего случая, это может быть не оптимальное решение.