Arrays 用c语言计算静态数组的移动平均值

我写这段代码是为了用c语言计算数组的移动平均值

Array_MovingAverage(const int inputSeries[], 
                    size_t inputSize, 
                    size_t window, 
                    float output[],
                    size_t outputSize) {
  if (inputSeries && output != NULL){
    for(size_t i = 0; i < window ; i++)
      if (window < inputSize)
        if (inputSeries != NULL && output != NULL) {
          if(outputSize >= inputSize) {
            size_t inputSize[11] =  {1, 2, 2, 3, 6, 8, 9, 2, 1, 2, 1};
            const uint8_t window = 5;
            {
              const int inputSeries[] = {1, 2, 2, 3, 6, 8, 9, 2, 1, 2,1};

              double window = 5;
              double c = 2.0;
              double d = 2.0;

              for(int i = 0; i < window; i++)
              {
                c += inputSeries[i];
                d = c / window;
              }

              return true;
            }
          }
        }
    }
  }

---

您的代码中有很多问题：

数组移动平均值（常量int inputSeries[]，大小inputSize，大小窗口，浮点输出[]，
大小（输出大小）{
if（inputSeries&&output！=NULL）{
对于（大小i=0；i

让我们从头开始。您尝试修改此代码只会让您不清楚您要做什么，而且原始代码在任何情况下都似乎有缺陷。处理代码的问题可能是徒劳的

首先，对于移动平均数N，您保留最后N个值的总和，对于每个新样本，您：

将样本[n]添加到总和

从总和中减去样本[n-n]

输出和/N

使用您的接口，但省略冗余的

outputSize

-输出与输入大小相同），实现可能如下所示：

void Array_MovingAverage( const int* inputSeries, 
                          size_t inputSize, 
                          size_t window, 
                          float* output ) 
{
    int sum = 0 ;

    if( inputSeries != NULL && output != 0 )
    {
        for( size_t i = 0; i < inputSize; i++ )
        {
            // Add newest sample
            sum += inputSeries[i] ;
            
            // Subtract oldest sample
            if( i >= window )
            {
                sum -= inputSeries[i - window] ;
            }
            
            output[i] = (float)sum / window ;
        }
    }
}

void Array_MovingAverage( const int* inputSeries, 
                          size_t inputSize, 
                          size_t window, 
                          float* output,
                          size_t outputSize ) 
{
    // Prevent unused warnings
    (void)inputSeries ;
    (void)inputSize ;
    (void)window ;

    // Local "input" data
    const int input[] = {1, 2, 2, 3, 6, 8, 9, 2, 1, 2, 1};
    const size_t size = sizeof(input) / sizeof(*input) ;
    const size_t width = 5 ;
 
    int sum = 0 ;

    if( input != NULL && output != 0 )
    {
        for( size_t i = 0; i < size; i++ )
        {
            // Add newest sample
            sum += input[i] ;
            
            // Subtract oldest sample
            if( i >= window )
            {
                sum -= input[i - width] ;
            }
            
            // Only write to caller output if index in bounds
            if( i < outputSize )
            {
                output[i] = (float)sum / window ;
            }
        }
    }
}

现在，您的问题还不清楚，但从其他评论来看，您似乎希望破解此函数以忽略调用者提供的输入，因为您无法修改调用者。坦率地说，这很奇怪，但这里有一个“安全”这样做的方法。让我们假设将恢复

outputSize

，因为很明显，您需要这样做来避免调用方输出缓冲区溢出。最简单的解决方案是将整个函数体包装为一个额外的大括号{…}允许您创建覆盖输入参数的阴影变量，保持代码的其余部分不变：

void Array_MovingAverage( const int* inputSeries, 
                          size_t inputSize, 
                          size_t window, 
                          float* output,
                          size_t outputSize ) 
{
    // Prevent unused warnings
    (void)inputSeries ;
    (void)inputSize ;
    (void)window ;

    // Create block to allow variables to be "shadowed"
    {
        // Override inputs
        // NASTY HACK
        const size_t inputSize = 11 ;
        const int inputSeries[11] = {1, 2, 2, 3, 6, 8, 9, 2, 1, 2, 1};
        const size_t window = 5 ;
        
        int sum = 0 ;
    
        if( inputSeries != NULL && output != 0 )
        {
            for( size_t i = 0; i < inputSize; i++ )
            {
                // Add newest sample
                sum += inputSeries[i] ;
                
                // Subtract oldest sample
                if( i >= window )
                {
                    sum -= inputSeries[i - window] ;
                }
                
                // Only write to caller output if index in bounds
                if( i < outputSize )
                {
                    output[i] = (float)sum / window ;
                }
            }
        }
    }
}

void数组\u MovingAverage（常量int*inputSeries，
大小\u t输入大小，
窗口大小，
浮点*输出，
大小（输出大小）
{
//防止未使用的警告
（无效）输入序列；
（空）输入大小；
（空）窗口；
//创建块以允许“隐藏”变量
{
//覆盖输入
//讨厌的黑客
常量大小\u t输入大小=11；
const int inputSeries[11]={1,2,2,3,6,8,9,2,1,2,1}；
const size_t window=5；
整数和=0；
if（inputSeries！=NULL&&output！=0）
{
对于（大小i=0；i=窗口）
{
总和-=输入序列[i-窗口]；
}
//仅当索引在边界内时写入调用方输出
如果（i<输出大小）
{
输出[i]=（浮点）和/窗口；
}
}
}
}
}

当然，您可以简单地更改变量名并忽略输入参数，但如果在任何复杂的现有工作代码中执行此操作，上述黑客可能不太容易出错（不重命名变量）。也就是说，这样的解决方案可能类似于：

void Array_MovingAverage( const int* inputSeries, 
                          size_t inputSize, 
                          size_t window, 
                          float* output ) 
{
    int sum = 0 ;

    if( inputSeries != NULL && output != 0 )
    {
        for( size_t i = 0; i < inputSize; i++ )
        {
            // Add newest sample
            sum += inputSeries[i] ;
            
            // Subtract oldest sample
            if( i >= window )
            {
                sum -= inputSeries[i - window] ;
            }
            
            output[i] = (float)sum / window ;
        }
    }
}

void Array_MovingAverage( const int* inputSeries, 
                          size_t inputSize, 
                          size_t window, 
                          float* output,
                          size_t outputSize ) 
{
    // Prevent unused warnings
    (void)inputSeries ;
    (void)inputSize ;
    (void)window ;

    // Local "input" data
    const int input[] = {1, 2, 2, 3, 6, 8, 9, 2, 1, 2, 1};
    const size_t size = sizeof(input) / sizeof(*input) ;
    const size_t width = 5 ;
 
    int sum = 0 ;

    if( input != NULL && output != 0 )
    {
        for( size_t i = 0; i < size; i++ )
        {
            // Add newest sample
            sum += input[i] ;
            
            // Subtract oldest sample
            if( i >= window )
            {
                sum -= input[i - width] ;
            }
            
            // Only write to caller output if index in bounds
            if( i < outputSize )
            {
                output[i] = (float)sum / window ;
            }
        }
    }
}

void数组\u MovingAverage（常量int*inputSeries，
大小\u t输入大小，
窗口大小，
浮点*输出，
大小（输出大小）
{
//防止未使用的警告
（无效）输入序列；
（空）输入大小；
（空）窗口；
//本地“输入”数据
常量int输入[]={1,2,2,3,6,8,9,2,1,2,1}；
常量size\u t size=sizeof（输入）/sizeof（*输入）；
const size\u t width=5；
整数和=0；
if（输入！=NULL&&output！=0）
{
对于（大小i=0；i=窗口）
{
总和-=输入[i-宽度]；
}
//仅当索引在边界内时写入调用方输出
如果（i<输出大小）
{
输出[i]=（浮点）和/窗口；
}
}
}
}

您为该函数提供了什么数据，如何调用它。您得到了什么输出而不是预期的输出？为什么要用局部变量覆盖参数？为什么要在循环中执行所有

if

检查？在输入函数时执行一次。还可以使用两个嵌套的

来执行
循环
i
作为计数器，两者都从
0..window
if（inputSeries&&output！=NULL）
非常棒！它在技术上是正确的，但令人难以置信地误导！我喜欢它！如果不打印任何内容，为什么您希望有任何输出？您还需要
void Array_MovingAverage( const int* inputSeries, 
                          size_t inputSize, 
                          size_t window, 
                          float* output,
                          size_t outputSize ) 
{
    // Prevent unused warnings
    (void)inputSeries ;
    (void)inputSize ;
    (void)window ;

    // Local "input" data
    const int input[] = {1, 2, 2, 3, 6, 8, 9, 2, 1, 2, 1};
    const size_t size = sizeof(input) / sizeof(*input) ;
    const size_t width = 5 ;
 
    int sum = 0 ;

    if( input != NULL && output != 0 )
    {
        for( size_t i = 0; i < size; i++ )
        {
            // Add newest sample
            sum += input[i] ;
            
            // Subtract oldest sample
            if( i >= window )
            {
                sum -= input[i - width] ;
            }
            
            // Only write to caller output if index in bounds
            if( i < outputSize )
            {
                output[i] = (float)sum / window ;
            }
        }
    }
}