//***********************************************
// parse substring of long string.
void parseSubstring(const std::string& str, const size_t  start_pos, const size_t end_pos, size_t idx, std::vector<int>*x)
{
	for (size_t i = start_pos; i<end_pos; i++)
	{
		char chr=str[i];
		x->at(idx)=atoi(&chr);
		idx--;
	}
};

BigInt::BigInt(const std::string& str)
{
	size_t num_cores = std::thread::hardware_concurrency(); // число ядер
	size_t str_size= str.size();

	const size_t block_size=str_size/num_cores;
	number= std::vector<int>(str_size);

	if(block_size==0) // do sequental parse
	{
		parseSubstring(str, 0, str_size, str_size-1, &number);
	}

	// do parallel parse into vector
	size_t idx=0;
	size_t block_num=0;
	size_t start_pos=0;
	size_t n_blocks=str_size/block_size;
	size_t end_pos=0;

	std::thread *threads= new std::thread[n_blocks];

	for(size_t block_num=0; block_num<n_blocks; block_num++)
	{
		start_pos=block_num*block_size;
		end_pos=start_pos+block_size;
		idx=str_size-block_size*block_num-1;
		threads[block_num]= std::thread(parseSubstring, str, start_pos, end_pos, idx, &number);
	}

	for(size_t i=0; i<n_blocks; i++)
		threads[i].join();
	
	// остаток. the remaining digits
	if(end_pos<str_size)
	{
		idx--; start_pos++;
		parseSubstring(str, start_pos, str_size, idx, &number);
	}
}

BigInt add(const BigInt& n1, const BigInt& n2)
{
	int n1_digit=n1.number.size();
	int n2_digit=n2.number.size();
	int n_digit=(n1_digit < n2_digit ? n1_digit : n2_digit);

	BigInt c;

	if(n1_digit>n2_digit)
	{
		n_digit=n2_digit;
		c.number = n1.number;
		
		// add
		for(int i=0; i<n_digit; i++)
		{
			c.number[i] += n2.number[i];
		}
	}
	else
	{	
		n_digit=n1_digit;
		c.number = n2.number;
		// add
		for(int i=0; i<n_digit; i++)
		{
			c.number[i] += n1.number[i];
		}
	}

	// processing carry flags
	n_digit=c.number.size()-1;
	for(int i=0; i<n_digit; i++)
	{
		if(c.number[i]>=10)
		{
			c.number[i]-=10;
			c.number[i+1]++;
		}
	}
	return c;
}

BigInt add_gpu(const BigInt& n1, const BigInt& n2)
{
	std::vector<int> data1 = n1.number; // первое слагаемое
	std::vector<int> data2 = n2.number; // второе
	std::vector<int> data_out(n1.number.size());

	// массив для первого числа  
	array_view<int, 1>av1(data1.size(), data1);
	
	// массив для второго числа
	array_view<int, 1>av2(data2.size(), data2);
	
	// массив для результата
	array_view<int, 1>av_data_out(data_out.size(),data_out);
	av_data_out.discard_data();

	// копируем массивы в видеоадаптер и суммируем 
	parallel_for_each(av1.extent, [=](concurrency::index<1> idx) restrict(amp)
	{
		av_data_out[idx] = av1[idx] + av2[idx];
	});

	// пересылаем результат в память процессора
	av_data_out.synchronize();
	
	// возвращаем результат
	BigInt c;
	c.number= data_out;
	return c;
}

BigInt add_gpu(BigInt& n1, BigInt& n2)
{
	BigInt c; c.number.resize(n1.number.size()); // результат

	// массив для первого числа. первое слагаемое
	array_view<int,1>av1(n1.number.size(),  dynamic_cast<std::vector<int>&>(n1.number)); 

	// массив для второго числа. второе слагаемое
	array_view<int,1>av2(n2.number.size(),  dynamic_cast<std::vector<int>&>(n2.number)); 

	// массив для результата
	array_view<int, 1>av_data_out(c.number.size(),c.number);
	av_data_out.discard_data();

	// копируем массивы в видеоадаптер и суммируем 
	parallel_for_each(av1.extent, [=](concurrency::index<1> idx) restrict(amp)
	{
		av_data_out[idx] = av1[idx] + av2[idx];
	});

	// пересылаем результат в память процессора
	av_data_out.synchronize();
	
	// возвращаем результат
	return c;
}

// складываем одни и теже числа 10000 раз
BigInt add_gpu(BigInt& n1, BigInt& n2)
{
	BigInt c; c.number.resize(n1.number.size()); // результат

	// массив для первого числа. первое слагаемое
	const array_view<int,1>av1(n1.number.size(),  dynamic_cast<std::vector<int>&>(n1.number)); 

	// массив для второго числа. второе слагаемое
	const array_view<int,1>av2(n2.number.size(),  dynamic_cast<std::vector<int>&>(n2.number)); 

	// массив для результата
	array_view<int, 1>av_data_out(c.number.size(),c.number);
	av_data_out.discard_data();

	// копируем массивы в видеоадаптер и суммируем 
	parallel_for_each(av1.extent, [=](concurrency::index<1> idx) restrict(amp)
	{

		for(int i=0; i<10000; i++) // 10000 раз
			av_data_out[idx] = av1[idx] + av2[idx];
	});

	// пересылаем результат в память процессора
	av_data_out.synchronize();
	
	// возвращаем результат
	return c;
}