#include<iostream>

 using namespace std;

 bool is_a_ge_zero_and_a_lt_b(int a,int b)

 {

     if(a>= && a <b) return true;

     return false;

 }

 void im2col_cpu(const float* data_im, const int channels,

     const int height, const int width, const int kernel_h, const int kernel_w,

     const int pad_h, const int pad_w,

     const int stride_h, const int stride_w,

     const int dilation_h, const int dilation_w,

     float* data_col) {

   const int output_h = (height +  * pad_h -

     (dilation_h * (kernel_h - ) + )) / stride_h + ;

   const int output_w = (width +  * pad_w -

     (dilation_w * (kernel_w - ) + )) / stride_w + ;

   const int channel_size = height * width;

   for (int channel = channels; channel--; data_im += channel_size) {

     for (int kernel_row = ; kernel_row < kernel_h; kernel_row++) {

       for (int kernel_col = ; kernel_col < kernel_w; kernel_col++) {

         int input_row = -pad_h + kernel_row * dilation_h;

         for (int output_rows = output_h; output_rows; output_rows--) {

           if (!is_a_ge_zero_and_a_lt_b(input_row, height)) {

             for (int output_cols = output_w; output_cols; output_cols--) {

               *(data_col++) = ;

             }

           } else {

             int input_col = -pad_w + kernel_col * dilation_w;

             for (int output_col = output_w; output_col; output_col--) {

               if (is_a_ge_zero_and_a_lt_b(input_col, width)) {

                 *(data_col++) = data_im[input_row * width + input_col];

               } else {

                 *(data_col++) = ;

               }

               input_col += stride_w;

             }

           }

           input_row += stride_h;

         }

       }

     }

   }

 }

 int main()

 {

      float* data_im;

     int height=;

     int width=;

     int kernel_h=;

     int kernel_w=;

     int pad_h=;

     int pad_w=;

     int stride_h=;

     int stride_w=;

     int dilation_h=;

     int dilation_w=;

     float* data_col;

     int channels =;

     const int output_h = (height +  * pad_h -

     (dilation_h * (kernel_h - ) + )) / stride_h + ;

       const int output_w = (width +  * pad_w -

     (dilation_w * (kernel_w - ) + )) / stride_w + ;

     data_im = new float[channels*height*width];

     data_col = new float[channels*output_h*output_w*kernel_h*kernel_w];

     //init input image data

     for(int m=;m<channels;++m)

     {

       for(int i=;i<height;++i)

       {

         for(int j=;j<width;++j)

         {

           data_im[m*width*height+i*width+j] = m*width*height+ i*width +j;

           cout <<data_im[m*width*height+i*width+j] <<' ';

         }

         cout <<endl;

       }

     }

     im2col_cpu(data_im, channels,

      height,width, kernel_h, kernel_w,

     pad_h, pad_w,

     stride_h, stride_w,

     dilation_h, dilation_w,

      data_col);

     cout <<channels<<endl;

     cout <<output_h<<endl;

     cout <<output_w<<endl;

     cout <<kernel_h<<endl;

     cout <<kernel_w<<endl;

    // cout <<"error"<<endl;

     for(int i=;i<kernel_w*kernel_h*channels;++i)

     {

         for(int j=;j<output_w*output_h;++j)

         {

             cout <<data_col[i*output_w*output_h+j]<<' ';

         }

         cout <<endl;

     }

     return ;

 }