Как заставить pow (float, int) вернуть float

еще один вопрос, на который можно честно ответить только "неправильным вопросом". Или, по крайней мере: "ты действительно хочешь туда пойти?". float теоретически требуется ca. 80% меньше умирает космос (для такого же количества циклов) и поэтому может быть гораздо дешевле для Навальной обработки. GPUs любовь float по этому поводу.

Однако давайте посмотрим на x86 (по общему признанию, вы не сказали, на какой архитектуре вы находитесь, поэтому я выбрал наиболее распространенный). Цена в космосе уже уплачена. Ты буквально ничего не получить с помощью float для расчетов. На самом деле, вы можете даже сбросить пропускная способность, потому что дополнительные расширения от float до double требуются и дополнительное округление до промежуточного float точности. Другими словами, вы платите дополнительно, чтобы иметь менее точный результат. Обычно этого следует избегать, за исключением случаев, когда вам нужна максимальная совместимость с какой-либо другой программой.

см. комментарий Йенса. Эти параметры дают компилятору разрешение игнорировать некоторые языковые правила для достижения более высокой производительности. Излишне говорить, что иногда это может привести к обратным результатам.

есть два сценария, где float может быть более эффективным, на x86:

• GPU (включая GPGPU), на самом деле многие графические процессоры даже не поддерживают double и если они это сделают, это обычно намного медленнее. Тем не менее, вы заметите только при выполнении очень многих вычислений такого рода.
• процессор SIMD ака векторизация

вы бы знали, Если бы вы сделали GPGPU. Явная векторизация с использованием встроенных компиляторов также является выбором – который вы могли бы сделать, конечно, но это требует довольно анализа затрат и выгод. Возможно, ваш компилятор способен автоматически векторизовать некоторые циклы, но это обычно ограничивается "очевидными" приложениями, например, где вы умножаете каждое число в vector<float> другое float, и этот случай не так очевиден ИМО. Даже если ты pow каждое число в таком векторе тем же int компилятор может быть достаточно умен, чтобы векторизовать это эффективно, особенно если pow находится в другом блоке перевода, и без эффективной генерации кода времени связи.

если вы не готовы рассмотреть возможность изменения всей структуры вашей программы, чтобы обеспечить эффективное использование SIMD (включая GPGPU), и вы не на архитектуре, где float - Это действительно намного дешевле, по умолчанию, я предлагаю вам придерживаться double непременно, и рассмотрим float в лучшем случае формат хранения, который может быть полезен для сохранения ОЗУ или улучшения местоположения кэша (когда у вас есть большое из них). Даже тогда измерение-отличная идея.

тем не менее, вы можете попробовать алгоритм ivaigult (только с double для промежуточного и для результата), который связан с классическим алгоритмом под названием египетские умножения (и множество других имен), только то, что операнды умножаются и не добавил. Я не знаю как!--17--> работает точно, но возможно, что этот алгоритм может быть быстрее в некоторых случаях. Опять же, вы должны быть ОКР о бенчмаркинге.

Если вы нацелились GCC вы можете попробовать

float __builtin_powif(float, int)

Я понятия не имею, насколько это сложно.

есть ли какая-то специальная функция (в стандартных библиотеках или любой другой) с вышеуказанной подписью?

к сожалению,я не знаю.

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

я собрал быстрый тест онлайн. Стандарт код:

#include <iostream>
#include <boost/timer/timer.hpp>
#include <boost/random/mersenne_twister.hpp>
#include <boost/random/uniform_real_distribution.hpp>
#include <cmath>

int main ()
{
    boost::random::mt19937 gen;
    boost::random::uniform_real_distribution<> dist(0, 10000000);

    const size_t size = 10000000;
    std::vector<float> bases(size);
    std::vector<float> fexp(size);
    std::vector<int> iexp(size);
    std::vector<float> res(size);

    for(size_t i=0; i<size; i++)
    {
        bases[i] = dist(gen);
        iexp[i] = std::floor(dist(gen));
        fexp[i] = iexp[i];
    }

    std::cout << "float pow(float, int):" << std::endl;
    {
        boost::timer::auto_cpu_timer timer;
        for(size_t i=0; i<size; i++)
            res[i] = std::pow(bases[i], iexp[i]);
    }

    std::cout << "float pow(float, float):" << std::endl;
    {
        boost::timer::auto_cpu_timer timer;
        for(size_t i=0; i<size; i++)
            res[i] = std::pow(bases[i], fexp[i]);
    }
    return 0;
}

результаты тестов (быстрые выводы):

• gcc: c++11 последовательно быстрее, чем c++03.
• лязг: действительно int-версия C++03, кажется, немного быстрее. Я не уверен, что это в пределах погрешности, так как я только запускаю тест онлайн.
• как: даже при вызове c++11 pow С int кажется, немного больше производительным.

было бы здорово, если бы другие могли проверить, выполняется ли это для их конфигураций.

вместо этого попробуйте использовать powf (). Это функция C99, которая также должна быть доступна в C++11.