44   	//This is called for a set of bins, instead of bin-by-bin, to avoid performance overhead

96   		//If we can finish in one iteration without exceeding either (2 to the MAX_SPLITS) or n bins, do so

120   		//Make sure there is space for the bins

146   		RandomAccessIter * bins = size_bins(bin_sizes, bin_cache, cache_offset, cache_end, bin_count);

152   		bins[0] = first;

154   			bins[u + 1] = bins[u] + bin_sizes[u];

160   			RandomAccessIter * local_bin = bins + u;

165   				for(target_bin = (bins + ((*current >> log_divisor) - div_min));  target_bin != local_bin; 

166   					target_bin = bins + ((*current >> log_divisor) - div_min)) {

171   					RandomAccessIter * b_bin = bins + ((*b >> log_divisor) - div_min);

185   		bins[bin_count - 1] = last;

209   	inline void inner_swap_loop(RandomAccessIter * bins, const RandomAccessIter & nextbinstart, unsigned ii, right_shift &shift

212   		RandomAccessIter * local_bin = bins + ii;

214   			for(RandomAccessIter * target_bin = (bins + (shift(*current, log_divisor) - div_min));  target_bin != local_bin; 

215   				target_bin = bins + (shift(*current, log_divisor) - div_min)) {

218   				RandomAccessIter * b_bin = bins + (shift(*b, log_divisor) - div_min);

237   	inline void swap_loop(RandomAccessIter * bins, RandomAccessIter & nextbinstart, unsigned ii, right_shift &shift

241   		inner_swap_loop<RandomAccessIter, div_type, data_type, right_shift>(bins, nextbinstart, ii, shift, log_divisor, div_min);

259   		RandomAccessIter * bins = size_bins(bin_sizes, bin_cache, cache_offset, cache_end, bin_count);

264   		bins[0] = first;

266   			bins[u + 1] = bins[u] + bin_sizes[u];

271   			swap_loop<RandomAccessIter, div_type, data_type, right_shift>(bins, nextbinstart, u, shift, bin_sizes, log_divisor, div_min);

272   		bins[bin_count - 1] = last;

307   		RandomAccessIter * bins = size_bins(bin_sizes, bin_cache, cache_offset, cache_end, bin_count);

312   		bins[0] = first;

314   			bins[u + 1] = bins[u] + bin_sizes[u];

319   			swap_loop<RandomAccessIter, div_type, data_type, right_shift>(bins, nextbinstart, ii, shift, bin_sizes, log_divisor, div_min);

320   		bins[bin_count - 1] = last;

438   	inline void inner_float_swap_loop(RandomAccessIter * bins, const RandomAccessIter & nextbinstart, unsigned ii

441   		RandomAccessIter * local_bin = bins + ii;

443   			for(RandomAccessIter * target_bin = (bins + ((cast_float_iter<div_type, RandomAccessIter>(current) >> log_divisor) - div_min));  target_bin != local_bin; 

444   				target_bin = bins + ((cast_float_iter<div_type, RandomAccessIter>(current) >> log_divisor) - div_min)) {

447   				RandomAccessIter * b_bin = bins + ((cast_float_iter<div_type, RandomAccessIter>(b) >> log_divisor) - div_min);

464   	inline void float_swap_loop(RandomAccessIter * bins, RandomAccessIter & nextbinstart, unsigned ii

468   		inner_float_swap_loop<RandomAccessIter, div_type, data_type>(bins, nextbinstart, ii, log_divisor, div_min);

500   		RandomAccessIter * bins = size_bins(bin_sizes, bin_cache, cache_offset, cache_end, bin_count);

505   		bins[0] = first;

507   			bins[u + 1] = bins[u] + bin_sizes[u];

512   			float_swap_loop<RandomAccessIter, div_type, data_type>(bins, nextbinstart, u, bin_sizes, log_divisor, div_min);

513   		bins[bin_count - 1] = last;

534   	//Note that bins are iterated in reverse order because max_neg_float = min_neg_int

549   		RandomAccessIter * bins = size_bins(bin_sizes, bin_cache, cache_offset, cache_end, bin_count);

554   		bins[bin_count - 1] = first;

556   			bins[ii] = bins[ii + 1] + bin_sizes[ii + 1];

562   			float_swap_loop<RandomAccessIter, div_type, data_type>(bins, nextbinstart, ii, bin_sizes, log_divisor, div_min);

585   	//Note that bins are iterated in reverse order because max_neg_float = min_neg_int

600   		RandomAccessIter * bins = size_bins(bin_sizes, bin_cache, cache_offset, cache_end, bin_count);

605   		bins[bin_count - 1] = first;

607   			bins[ii] = bins[ii + 1] + bin_sizes[ii + 1];

613   			swap_loop<RandomAccessIter, div_type, data_type, right_shift>(bins, nextbinstart, ii, shift, bin_sizes, log_divisor, div_min);

649   		RandomAccessIter * bins = size_bins(bin_sizes, bin_cache, cache_offset, cache_end, bin_count);

654   		bins[bin_count - 1] = first;

656   			bins[ii] = bins[ii + 1] + bin_sizes[ii + 1];

662   			swap_loop<RandomAccessIter, div_type, data_type, right_shift>(bins, nextbinstart, ii, shift, bin_sizes, log_divisor, div_min);

699   		RandomAccessIter * bins = size_bins(bin_sizes, bin_cache, cache_offset, cache_end, bin_count);

706   		//Resetting if all bins are negative

709   		//Reversing the order of the negative bins

714   			bins[first_positive - 1] = first;

716   				bins[ii] = first + bin_sizes[ii + 1];

721   				bins[first_positive] = first + bin_sizes[0];

726   			bins[0] = first;

728   			bins[u + 1] = first + bin_sizes[u];

736   			inner_float_swap_loop<RandomAccessIter, div_type, data_type>(bins, nextbinstart, u, log_divisor, div_min);

783   		RandomAccessIter * bins = size_bins(bin_sizes, bin_cache, cache_offset, cache_end, bin_count);

790   		//Resetting if all bins are negative

793   		//Reversing the order of the negative bins

798   			bins[first_positive - 1] = first;

800   				bins[ii] = first + bin_sizes[ii + 1];

805   				bins[first_positive] = first + bin_sizes[0];

810   			bins[0] = first;

812   			bins[u + 1] = first + bin_sizes[u];

820   			inner_swap_loop<RandomAccessIter, div_type, data_type, right_shift>(bins, nextbinstart, u, shift, log_divisor, div_min);

867   		RandomAccessIter * bins = size_bins(bin_sizes, bin_cache, cache_offset, cache_end, bin_count);

874   		//Resetting if all bins are negative

877   		//Reversing the order of the negative bins

882   			bins[first_positive - 1] = first;

884   				bins[ii] = first + bin_sizes[ii + 1];

889   				bins[first_positive] = first + bin_sizes[0];

894   			bins[0] = first;

896   			bins[u + 1] = first + bin_sizes[u];

904   			inner_swap_loop<RandomAccessIter, div_type, data_type, right_shift>(bins, nextbinstart, u, shift, log_divisor, div_min);

1130   		RandomAccessIter * bins = size_bins(bin_sizes, bin_cache, cache_offset, cache_end, membin_count) + 1;

1147   		//handling empty bins

1155   				target_bin = bins + static_cast<unsignedchar_type>((*current)[char_offset]);

1165   			local_bin = bins + u;

1170   				for(target_bin = bins + static_cast<unsignedchar_type>((*current)[char_offset]);  target_bin != local_bin; 

1171   					target_bin = bins + static_cast<unsignedchar_type>((*current)[char_offset]))

1176   		bins[last_bin] = last;

1219   		RandomAccessIter * bins = size_bins(bin_sizes, bin_cache, cache_offset, cache_end, membin_count);

1237   		//handling empty bins

1255   			local_bin = bins + u;

1266   		bins[last_bin] = lastFull;

1306   		RandomAccessIter * bins = size_bins(bin_sizes, bin_cache, cache_offset, cache_end, membin_count) + 1;

1323   		//handling empty bins

1331   				target_bin = bins + getchar((*current), char_offset);

1341   			local_bin = bins + ii;

1346   				for(target_bin = bins + getchar((*current), char_offset);  target_bin != local_bin; 

1347   					target_bin = bins + getchar((*current), char_offset))

1352   		bins[last_bin] = last;

1393   		RandomAccessIter * bins = size_bins(bin_sizes, bin_cache, cache_offset, cache_end, membin_count) + 1;

1410   		//handling empty bins

1418   				target_bin = bins + getchar((*current), char_offset);

1428   			local_bin = bins + u;

1433   				for(target_bin = bins + getchar((*current), char_offset);  target_bin != local_bin; 

1434   					target_bin = bins + getchar((*current), char_offset))

1439   		bins[last_bin] = last;

1483   		RandomAccessIter * bins = size_bins(bin_sizes, bin_cache, cache_offset, cache_end, membin_count);

1501   		//handling empty bins

1520   			local_bin = bins + u;

1531   		bins[last_bin] = lastFull;

Indexes created Wed Aug 24 13:21:36 CEST 2016