C++ blocked_range::end方法代码示例

 void operator() ( const blocked_range<size_t>& r ) const {
  for ( size_t i = r.begin(); i != r.end(); ++i ) {
   size_t max_size = 0, max_pos = 0;
   for (size_t j = 0; j < str.size(); ++j) 
    if (j != i) {
     size_t limit = str.size()-( i > j ? i : j );
     for (size_t k = 0; k < limit; ++k) {
      if (str[i + k] != str[j + k]) break;
      if (k+1 > max_size) {
       max_size = k+1;
       max_pos = j;
      }
     }
    }
   max_array[i] = max_size;
   pos_array[i] = max_pos;
  }
 }

		void operator()( const blocked_range<int>& r ) const {  
			for (int i=r.begin(); i!=r.end(); i++ ){  
				for(int j = 0; j < cols; ++j) {
					const int out_offset = i + (j*rows);
					// For each pixel, do the stencil
					for(int x = i - radius, kx = 0; x <= i + radius; ++x, ++kx) {
						for(int y = j - radius, ky = 0; y <= j + radius; ++y, ++ky) {
							if(x >= 0 && x < rows && y >= 0 && y < cols) {
								const int in_offset = x + (y*rows);
								const int k_offset = kx + (ky*dim);
								out[out_offset].red   += kernel[k_offset] * in[in_offset].red;
								out[out_offset].green += kernel[k_offset] * in[in_offset].green;
								out[out_offset].blue  += kernel[k_offset] * in[in_offset].blue;
							}
						}
					}
				}
			}  
		}  

  void operator_3( const blocked_range<size_t>& r ) {   
	double value;
	IntVector indexArray(m_lenArray.size());
	DoubleVector argArray(m_lenArray.size());
    Index1DToArray(r.begin(), m_lenArray, indexArray);

	int nStride0 = m_ControlGridArray[0].strides()[0];
	const char *pBegin0 = (const char*) (m_ControlGridArray[0].array().data());
	const char *pEnd0 = pBegin0 + (nStride0 * m_ControlGridArray[0].size());
	const char *pData0 = pBegin0 + (nStride0 * indexArray[0]);
	int nStride1 = m_ControlGridArray[1].strides()[0];
	const char *pBegin1 = (const char*) (m_ControlGridArray[1].array().data());
	const char *pEnd1 = pBegin1 + (nStride1 * m_ControlGridArray[1].size());
	const char *pData1 = pBegin1 + (nStride1 * indexArray[1]);
	int nStride2 = m_ControlGridArray[2].strides()[0];
	const char *pBegin2 = (const char*) (m_ControlGridArray[2].array().data());
	const char *pEnd2 = pBegin2 + (nStride2 * m_ControlGridArray[2].size());
	const char *pData2 = pBegin2 + (nStride2 * indexArray[2]);
	
    for( size_t index=r.begin(); index!=r.end(); ++index ){
      argArray[0] = * (double*) pData0;
	  argArray[1] = * (double*) pData1;
	  argArray[2] = * (double*) pData2;

  	  value = m_params.objectiveFunction(argArray);	  
      if (value > m_value_of_max) {
        m_value_of_max = value;
		m_argmax = argArray;
      }

	  pData2 += nStride2;
	  if (pData2 == pEnd2) {
	    pData2 = pBegin2;
	    pData1 += nStride1;
		if (pData1 == pEnd1) {
		  pData1 = pBegin1;
		  pData0 += nStride0;
		}
	  }	  
    }
  }

    void operator() (const blocked_range<uint64>& r)
    {
        const size_t size = v.size();
        uint64 size2 = size*2;
        for ( uint64 i=r.begin(); i<r.end(); ++i )
        {
            int len = 1;
            uint64 n = i;
            while ( n != 1 )
            {
                if ( n % 2 == 0 )
                {
                    n = n/2;
                    if ( n<size )
                    {
                        const short len1 = -v[size_t(n)];
                        if ( len1 > 0 )
                        {
                            len += len1;
                            break;
                        }
                    }
                    else if ( n<size2 )
                    {
                        const short len1 = v[size_t(n - size)];
                        if ( len1 > 0 )
                        {
                            len += len1;
                            break;
                        }
                    }
                }
                else
                    n = 3*n + 1;

                ++len;
            }
            v[size_t(i - size)] = len;
            updateResult(res, i, len);
        }
    }

  void operator_any( const blocked_range<size_t>& r ) {   
    char *pData = NULL;    
	double value, arg;
	unsigned int j;
	IntVector indexArray(m_lenArray.size());
	DoubleVector argArray(m_lenArray.size());
    
    for( size_t index=r.begin(); index!=r.end(); ++index ){
	  Index1DToArray(index, m_lenArray, indexArray);
	  for (j=0; j<indexArray.size(); j++) {
	    //pData = (m_gridPtrArray[j]->data) + (m_gridPtrArray[j]->strides[0] * indexArray[j]);
		pData = ((char*) (m_ControlGridArray[j].array().data())) + (m_ControlGridArray[j].strides()[0] * indexArray[j]);
		arg = * (double*) pData;
		argArray[j] = arg;
	  }
      value = m_params.objectiveFunction(argArray);	  
      if (value > m_value_of_max) {
        m_value_of_max = value;
		m_argmax = argArray;
      }
    }
  }

			void operator()( const blocked_range<size_t> &r ) const
			{
				for ( size_t i = r.begin(); i != r.end(); ++i )
				{
					for ( size_t j = 0; j < 1000; j++ )
					{
						if ( ( i + j ) % 7 == 0 )
						{
							SharedSceneInterfaces::clear();
						}

						ConstSceneInterfacePtr scene = SharedSceneInterfaces::get("test/IECore/data/sccFiles/attributeAtRoot.scc");

						try 
						{
							scene->readAttribute( m_attribute, 0 );
						}
						catch( Exception &e )
						{
							m_errors++;
						}
					}
				}
			}

// Note: parallel_tracks_vector should have n items allocated already.
void TBBSearchByPair::operator() (const blocked_range<int>& r) const{
  for (int i = r.begin(); i != r.end(); ++i) {
    searchByPair(i, parallel_tracks_vector[i]);
  }
}

 void operator()( const blocked_range<int>& range ) const {
     for( int i=range.begin(); i!=range.end(); ++i ) {
         output[i] = (input[i-1]+input[i]+input[i+1])*(1/3.f);
         cout << output[i] << ' ';
     }
 }

 //! iterate thorough range
 void operator()( const blocked_range<int> &range ) const {
     int i_end = range.end();
     for( int i = range.begin(); i != i_end; ++i ) {
         my_stream.Queue.push( Matrix1110 ); // push initial matrix
     }
 }

 void operator() ( const blocked_range<int>& r ) const {
   for ( int i = r.begin(); i != r.end(); i++ ) { // iterates over the entire chunk
     p_array_sum[i] = p_array_a[i] + p_array_b[i];
   }
 }

 void operator() (blocked_range<size_t>& r) const {
     for (size_t i=r.begin(); i!=r.end(); ++i) {
         f_distance[i] = g_distance[i] = INF;
         predecessor[i] = N;
     }
 }

		void operator()(const blocked_range<int>& r) const{
			int begin = r.begin(), end = r.end();
			for (int i = begin; i < end; i++){
				dst[i] = value;
			}
		}

 // the blocked_range<T> is a template class provided by the library
 // it describes a one-dimensional iteration space over type T
 void operator()(const blocked_range<size_t>& r) const
 {
     float* a = my_a;
     for (size_t i = r.begin(); i < r.end(); i++)
         foo(a[i]);
 }

		void operator()(const blocked_range<uint>& r) const {
			for(uint i=r.begin(); i!=r.end(); ++i) {
				c->buckets[i].clear();
			}
		}

 void operator()( const blocked_range<int>& range ) {
     for( int j=range.begin(); j!=range.end(); ++j ) 
         sum += my_a[j]*my_b[i-j];
 }