// Processing operator - in real life processes data for the range defined by 'r'
	//
	// This just calls TestThread.callback(r.begin(), r.end())
	// Designed to be called on any thread
	//
	void operator() (const blocked_range<int>& r ) const {
		// printf("operator() %d->%d\n", r.begin(), r.end());

		// Attach the current thread to the JVM, allowing access to the JVM environment through 'thrdEnv'
		JNIEnv *thrdEnv;
		jvm->AttachCurrentThread ((void **) &thrdEnv, NULL);

		// Get the TestThread instance as a jclass
		jclass cls = thrdEnv->GetObjectClass(testThread);
		if(cls==0) {
			fprintf(stderr, "GetObjectClass returned null\n");
			return;
		}

		// Get the method id for 'void TestThread.callback(int, int)'
		jmethodID mid = thrdEnv->GetMethodID(cls, "callback", "(II)V");
		if(mid==0) {
			fprintf(stderr, "GetMethodID returned null\n");
			return;
		}

		// Now call the actual method
		jint s = r.begin();
		jint e = r.end();
		thrdEnv->CallVoidMethod(testThread, mid, s, e );

		// And detach our thread
		jvm->DetachCurrentThread();
	};

 void operator()( const blocked_range<MyString*> range ) const {
     for( MyString* p=range.begin(); p!=range.end(); ++p ) {
         StringTable::accessor a;
         table.insert( a, *p );
         a->second += 1;
     }
 }

 void operator()( const blocked_range<int*>& r ) {
     int temp = value;
     for( int* a=r.begin(); a!=r.end(); ++a ) {
         temp += *a;
     }
     value = temp;
 }

	void operator()( const blocked_range<int>& range ) const
	{
		for( int i=range.begin(); i!=range.end(); ++i )
		{
			(*proc)(tiles[i],ImgRef1,ImgRef2,FeatMat);
		}
	}

 void operator() (const blocked_range<int>& range) const{
   int begin=range.begin();
   begin++;
   for ( int i = begin; i<=range.end(); ++i){
      input[i]=input[i-1]+input[i];
   }
 }

void
SOMap::epoch_update_range( SOM_element const &s, int epoch, int min_x, int min_y, double radius, double learning_rate, blocked_range<int> &r) {
    int min_xiter = (int)((double)min_x - radius);
    if(min_xiter < 0) min_xiter = 0;
    int max_xiter = (int)((double)min_x + radius);
    if(max_xiter > (int)my_map.size()-1) max_xiter = (int)my_map.size()-1;
    for(int xx = r.begin(); xx <= r.end(); ++xx) {
        double xrsq = (xx-min_x)*(xx-min_x);
        double ysq = radius*radius - xrsq;  // max extent of y influence
        double yd;
        if(ysq > 0) {
            yd = sqrt(ysq);
            int lb = (int)(min_y - yd);
            int ub = (int)(min_y + yd);
            for(int yy = lb; yy < ub; ++yy) {
                if(yy >= 0 && yy < (int)my_map[xx].size()) {
                    // [xx, yy] is in the range of the update.
                    double my_rsq = xrsq + (yy-min_y)*(yy-min_y);  // distance from BMU squared
                    double theta = exp(-(radius*radius) /(2.0* my_rsq)); 
                    add_fraction_of_difference(my_map[xx][yy], s, theta * learning_rate);
                }
            }
        }
    }
}

  void operator_2( 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_lenArray[0]);
	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_lenArray[1]);
	const char *pData1 = pBegin1 + (nStride1 * indexArray[1]);
	
    for( size_t index=r.begin(); index!=r.end(); ++index ){
      argArray[0] = * (double*) pData0;
	  argArray[1] = * (double*) pData1;

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

	  pData1 += nStride1;
	  if (pData1 == pEnd1) {
	    pData1 = pBegin1;
	    pData0 += nStride0;
	  }	  
    }
  }

    void operator() (const blocked_range<uint64>& r)
    {
        const size_t size = v.size();
        const size_t size2 = 2*size;
        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<size2 )
                    {
                        len += v[size_t(n - size)];
                        break;
                    }
                }
                else
                    n = 3*n + 1;

                ++len;
            }
            updateResult(res, i, len);
        }
    }

                void operator()(const blocked_range<int>& r) const {
                	char tempChar = ciChar;
                	for(int i = r.begin(); i!= r.end(); i++) {
                        	tempChar = tempChar ^ getBit((&list[i]),loop); 	
                        }
				cyText[loop] = tempChar;
  	           
                 }

void Render::operator()(const blocked_range<int>& r) const
{
	for (int j = r.begin(); j != r.end(); j++) {
		for (int i = 0; i < rt->cam.pw; i++) {
			rt->getPixel(i, j);
		}
	}
}

 void operator()( const blocked_range<size_t>& r ) const {
     for( size_t i=r.begin(); i!=r.end(); ++i )
     {
     	Iterate(*object_points, *image_points, *camera_matrix, *dist_coeffs,
     	        *resultRvec, *resultTvec, max_dist, min_inlier_num,
     	        inliers, use_extrinsic_guess, rvecInit, tvecInit, *rng, ResultsMutex);
     }
 }

 void operator() (blocked_range<size_t>& r) const {
     utility::FastRandom my_random((unsigned int)r.begin());
     for (size_t i=r.begin(); i!=r.end(); ++i) {
         for (size_t j=0; j<i; ++j) {
             if (die_toss(i, j, my_random))
                 edges[i].push_back(j);
         }
     }
 }

			void operator()( const blocked_range<size_t> &r ) const
			{
				Imath::Rand32 rand;
				for( size_t i=r.begin(); i!=r.end(); ++i )
				{
					std::string s = lexical_cast<std::string>( rand.nexti() % 1000 );
					InternedString ss( s );
				}
			}

 void operator()( const blocked_range<int> &r, Tag tag) {
     for( int k = r.begin(); k < r.end(); ++k ) {
         // Code performs an "exclusive" scan, which outputs a value *before* updating the product.
         // For an "inclusive" scan, output the value after the update.
         if( tag.is_final_scan() )
             output[k] = product.v[0][1];
         product = product * Matrix1110;
     }
 }

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

				for(uint elem=0; elem < c->buckets[i].size(); ++elem) {
					(*(c->arr))[base_index + elem] = c->buckets[i][elem];
				}
			}
		}

void operator() (blocked_range<size_t>&r)const
{
double *vA,*vB,*vR;
vA=vectA;
vB=vectB;
vR=resultVect;
for(size_t count=r.begin();count!=r.end();count++)
vR[count]=vA[count]*vB[count];
}

  void operator()(blocked_range<size_t>&r) {
    const float *a = array;
    for (size_t i = r.begin();  i != r.end(); ++i) {
      float value = array[i];
      if (value < value_of_min) {
	value_of_min = value;
	ind_of_min = i;
      }
    }
  }

 void operator()(const blocked_range<size_t>& r)
 {
     double rectWidth = * my_rects;
     double x;
     for(size_t i = r.begin(); i != r.end(); ++i)
     {
         x = (i + 0.5) * rectWidth;
         partialHeight += 4.0 / (1.0 + x * x );
     }
 }

  void operator() (blocked_range<size_t> const& r)
  {
    float* arr = m_arr;
    float  sum = m_sum;
    size_t end = r.end();
    for (size_t i=r.begin(); i!=end; ++i)
      sum += Foo(arr[i]);

    m_sum = sum;
  }

    void operator()( const blocked_range<int>& range ) const {
        for( int i=range.begin(); i!=range.end(); ++i ) {
            int start = i<n ? 0 : i-n+1;
            int finish = i<m ? i+1 : m; 
            T sum = 0;
#pragma omp parallel for reduction(+:sum)
            for( int j=start; j<finish; ++j ) 
                sum += my_a[j]*my_b[i-j];
            my_c[i] = sum;
        }
    }