Home | History | Annotate | Download | only in spreadsortlib

Lines Matching refs:bins

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

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

115   		//Make sure there is space for the bins

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

147   		bins[0] = first;

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

155   			RandomAccessIter * local_bin = bins + u;

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

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

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

180   		bins[bin_count - 1] = last;

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

207   		RandomAccessIter * local_bin = bins + ii;

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

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

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

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

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

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

259   		bins[0] = first;

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

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

267   		bins[bin_count - 1] = last;

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

307   		bins[0] = first;

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

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

315   		bins[bin_count - 1] = last;

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

436   		RandomAccessIter * local_bin = bins + ii;

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

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

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

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

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

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

500   		bins[0] = first;

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

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

508   		bins[bin_count - 1] = last;

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

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

549   		bins[bin_count - 1] = first;

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

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

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

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

600   		bins[bin_count - 1] = first;

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

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

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

649   		bins[bin_count - 1] = first;

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

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

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

701   		//Resetting if all bins are negative

704   		//Reversing the order of the negative bins

709   			bins[first_positive - 1] = first;

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

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

721   			bins[0] = first;

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

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

778   		RandomAccessIter * bins
785   		//Resetting if all bins are negative

788   		//Reversing the order of the negative bins

793   			bins[first_positive - 1] = first;

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

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

805   			bins[0] = first;

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

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

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

869   		//Resetting if all bins are negative

872   		//Reversing the order of the negative bins

877   			bins[first_positive - 1] = first;

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

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

889   			bins[0] = first;

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

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

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

1142   		//handling empty bins

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

1160   			local_bin = bins + u;

1165   				for(target_bin = bins
1166   					target_bin = bins + static_cast<unsignedchar_type>((*current)[char_offset]))

1171   		bins[last_bin] = last;

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

1232   		//handling empty bins

1250   			local_bin = bins + u;

1261   		bins[last_bin] = lastFull;

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

1318   		//handling empty bins

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

1336   			local_bin = bins + ii;

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

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

1347   		bins[last_bin] = last;

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

1405   		//handling empty bins

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

1423   			local_bin = bins + u;

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

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

1434   		bins[last_bin] = last;

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

1496   		//handling empty bins

1515   			local_bin = bins + u;

1526   		bins[last_bin] = lastFull;