结合整数和浮点数:性能注意事项

i具有一组复杂的模板函数，可以在循环中进行计算，结合浮点数和UINT32_T循环索引。我很惊讶地发现，对于这种功能，我的测试代码以双重精度浮点数的运行速度要比单个精确度更快。

作为测试，我将索引的格式更改为uint16_t。此后，该程序的双重版本和浮点版本都更快（如预期的那样），但是现在浮点版的速度明显快于双版本。我还使用UINT64_T索引测试了该程序。在这种情况下，双重和浮点版本同样慢。

我想这是因为uint32_t适合双曼氏杀剂，但不适合浮子。一旦索引类型简化为UINT16_T，它们也会适合浮子的遮刀，转换应该是微不足道的。对于UINT64_T，转换为double也需要舍入，这将解释为什么两个版本都同样执行。

任何人都可以确认此解释吗？

编辑：使用int或长度为索引类型，程序运行的速度与unit16_t一样快。我想这反对我首先怀疑。

编辑：我在x86体系结构上编辑了Windows的程序。

编辑：这是一块代码，它可以重现Double作为UINT32_T的浮动速度更快的效果，并且两种情况对于INT而言同样快。请不要对该代码的有用性发表评论。这是代码的修改片段，可再现效果，无明智的作用。

主文件：

#include "stdafx.h"
typedef short spectraType;
typedef int intermediateValue;
typedef double returnType;
#include "Preprocess_t.h"
#include "Windows.h"
#include <iostream>
int main()
{
    const size_t numberOfBins = 10000;
    const size_t numberOfSpectra = 500;
    const size_t peakWidth = 25;
    bool startPeak = false;
    short peakHeight;
    Preprocess<short, returnType> myPreprocessor;
    std::vector<returnType> processedSpectrum;
    std::vector<std::vector<short>> spectra(numberOfSpectra, std::vector<short>(numberOfBins));

    std::vector<float> peakShape(peakWidth);
    LARGE_INTEGER freq, start, stop;
    double time_ms;
    QueryPerformanceFrequency(&freq);

    for (size_t i = 0; i < peakWidth; ++i)
    {
        peakShape[i] = static_cast<float>(exp(-(i - peakWidth / 2.0) *(i - peakWidth / 2.0) / 10.0));
    }

    for (size_t i = 0; i < numberOfSpectra; ++i)
    {
        size_t j = 0;
        for (; j < 200; ++j)
        {
            spectra[i][j] = rand() % 100;
        }
        for (size_t k = 0; k < 25; ++k)
        {
            spectra[i][j] = static_cast<short>(16383 * peakShape[k]);
            j++;
        }
        for (; j < numberOfBins; ++j)
        {
            startPeak = !static_cast<bool>(abs(rand()) % (numberOfBins / 4));
            if (startPeak)
            {
                peakHeight = rand() % 16384;
                for (size_t k = 0; k < 25 && j< numberOfBins; ++k)
                {
                    spectra[i][j] = peakHeight * peakShape[k] + rand() % 100;
                    j++;
                }
            }
            else
            {
                spectra[i][j] = rand() % 100;
            }
        }
        for (j = 0; j < numberOfBins; ++j)
        {
            double temp = 1000.0*exp(-(static_cast<float>(j) / (numberOfBins / 3.0)))*sin(static_cast<float>(j) / (numberOfBins / 10.0));
            spectra[i][j] -= static_cast<short>(1000.0*exp(-(static_cast<float>(j) / (numberOfBins / 3.0)))*sin(static_cast<float>(j) / (numberOfBins / 10.0)));
        }
    }
    // This is where the critical code is called
    QueryPerformanceCounter(&start);
    for (int i = 0; i < numberOfSpectra; ++i)
    {
        myPreprocessor.SetSpectrum(&spectra[i], 1000, &processedSpectrum);
        myPreprocessor.CorrectBaseline(30, 2.0);
    }
    QueryPerformanceCounter(&stop);
    time_ms = static_cast<double>(stop.QuadPart - start.QuadPart) / static_cast<double>(freq.QuadPart);
    std::cout << "time spend preprocessing: " << time_ms << std::endl;
    std::cin.ignore();
    return 0;
}

和随附的标头Preprocess_t.h：

#pragma once
#include <vector>
//typedef unsigned int indexType;
typedef unsigned short indexType;
template<typename T, typename Out_Type>
class Preprocess
{
public:
    Preprocess() :threshold(1), sdev(1), laserPeakThreshold(500), a(0), b(0), firstPointUsedAfterLaserPeak(0) {};
    ~Preprocess() {};
    void SetSpectrum(std::vector<T>* input, T laserPeakThreshold, std::vector<Out_Type>* processedSpectrum); ///@note We need the laserPeakThresholdParameter for the baseline correction, not onla for the shift.
    void CorrectBaseline(indexType numberOfPoints, Out_Type thresholdFactor);
private:
    void LinFitValues(indexType beginPoint);
    Out_Type SumOfSquareDiffs(Out_Type x, indexType n);
    Out_Type LinResidualSumOfSquareDist(indexType beginPoint);
    std::vector<T>* input;
    std::vector<Out_Type>* processedSpectrum;
    std::vector<indexType> fitWave_X;
    std::vector<Out_Type> fitWave;
    Out_Type threshold;
    Out_Type sdev;
    T laserPeakThreshold;
    Out_Type a, b;
    indexType firstPointUsedAfterLaserPeak;
    indexType numberOfPoints;
};
template<typename T, typename Out_Type>
void Preprocess<T, Out_Type>::CorrectBaseline(indexType numberOfPoints, Out_Type thresholdFactor)
{
    this->numberOfPoints = numberOfPoints;
    indexType numberOfBins = input->size();
    indexType firstPointUsedAfterLaserPeak = 0;
    indexType positionInFitWave = 0;
    positionInFitWave = firstPointUsedAfterLaserPeak;
    for (indexType i = firstPointUsedAfterLaserPeak; i < numberOfBins - numberOfPoints; i++) {
        LinFitValues(positionInFitWave);
        processedSpectrum->at(i + numberOfPoints) = input->at(i + numberOfPoints) - static_cast<Out_Type>(a + b*(i + numberOfPoints));

        positionInFitWave++;
        fitWave[positionInFitWave + numberOfPoints - 1] = input->at(i + numberOfPoints - 1);
        fitWave_X[positionInFitWave + numberOfPoints - 1] = i + numberOfPoints - 1;
    }
}
template<typename T, typename Out_Type>
void Preprocess<T, Out_Type>::LinFitValues(indexType beginPoint)
{
    Out_Type y_mean, x_mean, SSxy, SSxx, normFactor;
    y_mean = x_mean = SSxy = SSxx = normFactor = static_cast<Out_Type>(0);
    indexType endPoint = beginPoint + numberOfPoints;
    Out_Type temp;
    if ((fitWave_X[endPoint - 1] - fitWave_X[beginPoint]) == numberOfPoints)
    {
        x_mean = (fitWave_X[endPoint - 1] - fitWave_X[beginPoint]) / static_cast<Out_Type>(2);
        for (indexType i = beginPoint; i < endPoint; i++) {
            y_mean += fitWave[i];
        }
        y_mean /= numberOfPoints;
        SSxx = SumOfSquareDiffs(x_mean, fitWave_X[endPoint - 1]) - SumOfSquareDiffs(x_mean, fitWave_X[beginPoint]);
        for (indexType i = beginPoint; i < endPoint; i++)
        {
            SSxy += (fitWave_X[i] - x_mean)*(fitWave[i] - y_mean);
        }
    }
    else
    {
        for (indexType i = beginPoint; i < endPoint; i++) {
            y_mean += fitWave[i];
            x_mean += fitWave_X[i];
        }
        y_mean /= numberOfPoints;
        x_mean /= numberOfPoints;
        for (indexType i = beginPoint; i < endPoint; i++)
        {
            temp = (fitWave_X[i] - x_mean);
            SSxy += temp*(fitWave[i] - y_mean);
            SSxx += temp*temp;
        }
    }
    b = SSxy / SSxx;
    a = y_mean - b*x_mean;
}
template<typename T, typename Out_Type>
inline Out_Type Preprocess<T, Out_Type>::SumOfSquareDiffs(Out_Type x, indexType n)
{
    return n*x*x + n*(n - 1)*x + ((n - 1)*n*(2 * n - 1)) / static_cast<Out_Type>(6);
}
template<typename T, typename Out_Type>
Out_Type Preprocess<T, Out_Type>::LinResidualSumOfSquareDist(indexType beginPoint) 
{
    Out_Type sumOfSquares = 0;
    Out_Type temp;
    for (indexType i = 0; i < numberOfPoints; ++i) {
        temp = fitWave[i + beginPoint] - (a + b*fitWave_X[i + beginPoint]);
        sumOfSquares += temp*temp;
    }
    return sumOfSquares;
}

template<typename T, typename Out_Type>
inline void Preprocess<T, Out_Type>::SetSpectrum(std::vector<T>* input, T laserPeakThreshold, std::vector<Out_Type>* processedSpectrum)
{
    this->input = input;
    fitWave_X.resize(input->size());
    fitWave.resize(input->size());
    this->laserPeakThreshold = laserPeakThreshold;
    this->processedSpectrum = processedSpectrum;
    processedSpectrum->resize(input->size());
}