no match for ‘operator[]’ というエラーが出る

解決したいこと

gnuradioの自作ブロックをc++で書いているのですが、" no match for ‘operator[]’ "というエラーが出てしまいます。
配列を宣言したり等、色々試したのですが解決しません。
何が原因なのでしょうか。
わかる方、いらっしゃいましたら教えていただきたいです。よろしくお願いします。

発生している問題・エラーメッセージ

/home/nomo/gr-Kurtosis_only/lib/Kurtosis_only_c_impl.cc:88:16: error: no match for ‘operator[]’ (operand types are ‘gr_complex’ {aka ‘std::complex<float>’} and ‘int’)
   88 |             S1r[i]  =  S1r[i]  +  pwr;
      |                ^

該当のc++のソースコード

Kurtosis_only_c_impl.cc
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <gnuradio/io_signature.h>
#include "Kurtosis_only_c_impl.h"

namespace gr {
  namespace Kurtosis_only {

    using input_type = gr_complex;
    using output_type = gr_complex;
    
    Kurtosis_only_c::sptr
    Kurtosis_only_c::make(int large_loop, int small_loop)
    {
      return gnuradio::get_initial_sptr
        (new Kurtosis_only_c_impl(large_loop, small_loop));
    }


    /*
     * The private constructor
     */
    Kurtosis_only_c_impl::Kurtosis_only_c_impl(int large_loop, int small_loop)
      : gr::sync_block("Kurtosis_only_c",
              gr::io_signature::make(1, 1, sizeof(input_type)),
              gr::io_signature::make(2, 2, sizeof(output_type))),
              d_LL(large_loop), d_SL(small_loop)
    {}

    /*
     * Our virtual destructor.
     */
    Kurtosis_only_c_impl::~Kurtosis_only_c_impl()
    {
    }

    int
    Kurtosis_only_c_impl::work(int noutput_items,
        gr_vector_const_void_star &input_items,
        gr_vector_void_star &output_items)
    {
      auto in0  = static_cast<const input_type*>(input_items[0]);
      auto out0 = static_cast<output_type*>(output_items[0]);
      
      /*gr_complex pwr, pwi;
      
      gr_complex S1r[d_SL], S1i[d_SL], S2r[d_SL], S2i[d_SL], S3r[d_SL], S3i[d_SL], 
                           S4r[d_SL], S4i[d_SL];
                           
      gr_complex dcnt[d_SL];
      
      gr_complex Myu1r[d_SL], Myu1i[d_SL], Myu2r[d_SL], Myu2i[d_SL], Myu3r[d_SL], 
                           Myu3i[d_SL], Myu4r[d_SL], Myu4i[d_SL];
                           
      Kurtosis_only_c_impl Kr[d_SL], Ki[d_SL];*/
      
      for(int k = 0; k < noutput_items; k++)
      {
        for(int j = 0; j < d_LL; j++)
        {
          for(int i = 0; i < d_SL; i++)
          {
            pwr =  in0[i].real();
            pwi =  in0[i].imag();
	    
            S1r[i]  =  S1r[i]  +  pwr;
            S1i[i]  =  S1i[i]  +  pwi;
	    
            S2r[i]  =  S2r[i]  +  pwr * pwr;
            S2i[i]  =  S2i[i]  +  pwi * pwi;
	    
	    S3r[i]  =  S3r[i]  +  pwr * pwr * pwr;
	    S3i[i]  =  S3i[i]  +  pwi * pwi * pwi;
	    
	    S4r[i]  =  S4r[i]  +  pwr * pwr * pwr * pwr;
	    S4i[i]  =  S4i[i]  +  pwi * pwi * pwi * pwi;
	    
	    dcnt[i] =  dcnt[i] +  1;
	    
          }
	  
          for(int i = 0; i < d_SL; i++)
          {
            Myu1r[i] = S1r[i] / dcnt[i];
            Myu1i[i] = S1i[i] / dcnt[i];
	  
            Myu2r[i] = S2r[i] / dcnt[i];
            Myu2i[i] = S2i[i] / dcnt[i];
	  
            Myu3r[i] = S3r[i] / dcnt[i];
            Myu3i[i] = S3i[i] / dcnt[i];
	  
            Myu4r[i] = S4r[i] / dcnt[i];
            Myu4i[i] = S4i[i] / dcnt[i];
          }

          for(int i = 0; i < d_SL; i++)
          {	  
            Kr[i] = (Myu4r[i] - 4 * Myu3r[i] * Myu1r[i] + 6 * Myu2r[i] * Myu1r[i] 
                   * Myu1r[i] - 3 * Myu1r[i] * Myu1r[i] * Myu1r[i] * Myu1r[i]) / 
                    ((Myu2r[i] - Myu1r[i] * Myu1r[i]) * (Myu2r[i] - Myu1r[i] 
                      * Myu1r[i]));
	  
            Ki[i] = (Myu4i[i] - 4 * Myu3i[i] * Myu1i[i] + 6 * Myu2i[i] * Myu1i[i] 
                   * Myu1i[i] - 3 * Myu1i[i] * Myu1i[i] * Myu1i[i] * Myu1i[i]) / 
                    ((Myu2i[i] - Myu1i[i] * Myu1i[i]) * (Myu2i[i] - Myu1i[i] 
                      * Myu1i[i]));
          }
          
          for(int i = 0; i < d_SL; i++)
          {
            out0[i][0] = Kr[i];
            out0[i][1] = Ki[i];
          }
        }
      }
      
      return noutput_items;
    }

  } /* namespace Kurtosis_only */
} /* namespace gr */

Kurtosis_only_c_impl.h
#ifndef INCLUDED_KURTOSIS_ONLY_KURTOSIS_ONLY_C_IMPL_H
#define INCLUDED_KURTOSIS_ONLY_KURTOSIS_ONLY_C_IMPL_H

#include <Kurtosis_only/Kurtosis_only_c.h>

namespace gr {
  namespace Kurtosis_only {

    class Kurtosis_only_c_impl : public Kurtosis_only_c
    {
     private:
       gr_complex pwr;
       gr_complex pwi;
       gr_complex S1r;
       gr_complex S1i;
       gr_complex S2r;
       gr_complex S2i;
       gr_complex S3r;
       gr_complex S3i;
       gr_complex S4r;
       gr_complex S4i;
       gr_complex Myu1r;
       gr_complex Myu1i;
       gr_complex Myu2r;
       gr_complex Myu2i;
       gr_complex Myu3r;
       gr_complex Myu3i;
       gr_complex Myu4r;
       gr_complex Myu4i;
       gr_complex Kr;
       gr_complex Ki;
       gr_complex dcnt;
       
       int d_LL;
       int d_SL;
       
     public:
      Kurtosis_only_c_impl(int large_loop, int small_loop);
      ~Kurtosis_only_c_impl();

      // Where all the action really happens
      int work(
              int noutput_items,
              gr_vector_const_void_star &input_items,
              gr_vector_void_star &output_items
      );
    };

  } // namespace Kurtosis_only
} // namespace gr

#endif /* INCLUDED_KURTOSIS_ONLY_KURTOSIS_ONLY_C_IMPL_H */