static inline void fix_priority_queue(queue the_queue)
{
int left, right;
int index;
int smallest;
index = 1;
while (index < the_queue->num_elements)
{
left = 2*index;
right = 2*index+1;
if (left <= the_queue->num_elements &&
the_queue->data_array[left-1]->utility <
the_queue->data_array[index-1]->utility)
smallest = left;
else
smallest = index;
if (right <= the_queue->num_elements &&
the_queue->data_array[right-1]->utility <
the_queue->data_array[smallest - 1]->utility)
smallest = right;
if (smallest != index)
{
swap_entries(smallest, index, the_queue);
index = smallest;
}
else
break;
}
}
static carmen_inline void
fix_priority_queue(queue the_queue)
{
int left, right;
int index;
int largest;
index = 1;
while (index < the_queue->num_elements)
{
left = 2*index;
right = 2*index+1;
if (left <= the_queue->num_elements &&
the_queue->data_array[left-1]->cost > the_queue->data_array[index-1]->cost)
largest = left;
else
largest = index;
if (right <= the_queue->num_elements &&
the_queue->data_array[right-1]->cost > the_queue->data_array[largest - 1]->cost)
largest = right;
if (largest != index)
{
swap_entries(largest, index, the_queue);
index = largest;
}
else
break;
}
}
void cache_randomize(const struct peer_cache *c)
{
int i;
for (i = 0; i < c->current_size - 1; i++) {
int j, k;
uint32_t ts = c->entries[i].timestamp;
for (j = i + 1; j < c->current_size; j++) {
if (c->entries[j].timestamp != ts) {
break;
}
}
//permutate entries from i to j-1
if (j - 1 > i) {
for (k = i; k < j - 1; k++) {
int r;
double rd;
r = (rand() / (RAND_MAX + 1.0)) * (j - k);
swap_entries(c, k, k + r);
}
}
i = j - 1;
}
}
/**
* Shuffle the playlist.
*
*/
static void
xmms_playlist_client_shuffle (xmms_playlist_t *playlist, const gchar *plname,
xmms_error_t *err)
{
guint j,i;
gint len, currpos;
xmmsv_coll_t *plcoll;
g_return_if_fail (playlist);
g_mutex_lock (playlist->mutex);
plcoll = xmms_playlist_get_coll (playlist, plname, err);
if (plcoll == NULL) {
xmms_error_set (err, XMMS_ERROR_NOENT, "no such playlist");
g_mutex_unlock (playlist->mutex);
return;
}
currpos = xmms_playlist_coll_get_currpos (plcoll);
len = xmms_playlist_coll_get_size (plcoll);
if (len > 1) {
/* put current at top and exclude from shuffling */
if (currpos != -1) {
swap_entries (plcoll, 0, currpos);
currpos = 0;
xmms_collection_set_int_attr (plcoll, "position", currpos);
}
/* knuth <3 */
for (i = currpos + 1; i < len; i++) {
j = g_random_int_range (i, len);
if (i != j) {
swap_entries (plcoll, i, j);
}
}
}
XMMS_PLAYLIST_CHANGED_MSG (XMMS_PLAYLIST_CHANGED_SHUFFLE, 0, plname);
XMMS_PLAYLIST_CURRPOS_MSG (currpos, plname);
g_mutex_unlock (playlist->mutex);
}
//******************************************
BOOLEAN PERMUTATION::dict_advance()
{
//dict = dictionary
//In dictionary ordering,
//first permutation is the identity permutation
//(pmut[0]=0, pmut[1]=1, etc. ).
//This method advances the permutation to
//the next permutation in dictionary ordering.
//It returns false if we've reached the last one.
//Otherwise it returns true.
//Ref:book "Combinatorial Generation", by Joe Sawada
/*
Example
04321
step:14320
step:10324
step:10234
*/
SHORT k, j;
SHORT s, r;
ThrowIf_(its_len<=1);
k = its_len - 2;
while(its_array_p[k] > its_array_p[k+1]){
k--;
if(k==-1)break;
}
if (k == -1){
return false;
}else{
j = its_len - 1;
while(its_array_p[k] > its_array_p[j]){
j--;
}
swap_entries(j, k);
s = k+1; r = its_len - 1;
while(s<r){
swap_entries(r, s);
s++; r--;
}
}
return true;
}
static void sort_entries() {
int swapped, e;
do {
swapped = 0;
for(e = 0; e < list->num_entries - 1; e++) {
if(direntries[e]->is_file && !direntries[e+1]->is_file) {
swap_entries(e);
swapped = 1;
}
if(!direntries[e]->is_file && direntries[e+1]->is_file) {
continue;
}
if(strcasecmp(direntries[e]->name, "..") > 0 &&
strcasecmp(direntries[e]->name, direntries[e+1]->name) > 0) {
swap_entries(e);
swapped = 1;
}
}
} while(swapped);
}
//******************************************
BOOLEAN PERMUTATION::rev_dict_advance()
{
//rev_dict = reverse dictionary
//In reverse dictionary ordering,
//last permutation is the identity permutation
//(pmut[0]=0, pmut[1]=1, etc. ).
//This method advances the permutation to
//the next permutation in reverse dictionary ordering.
//It returns false if we've reached the last one.
//Otherwise it returns true.
//see PERMUTATION::dict_advance()
SHORT k, j;
SHORT s, r;
ThrowIf_(its_len<=1);
k = its_len - 2;
while(its_array_p[its_len -1 - k] > its_array_p[its_len -2 - k]){
k--;
if(k==-1)break;
}
if (k == -1){
return false;
}else{
j = its_len - 1;
while(its_array_p[its_len -1 - k] > its_array_p[its_len -1 - j]){
j--;
}
swap_entries(its_len -1 - j, its_len -1 - k);
s = k+1; r = its_len - 1;
while(s<r){
swap_entries(its_len -1 - r, its_len -1 - s);
s++; r--;
}
}
return true;
}
static inline void insert_into_queue(state_ptr new_state, queue the_queue)
{
int index;
if (!the_queue->queue_size ||
the_queue->queue_size == the_queue->num_elements)
resize_queue(the_queue);
the_queue->data_array[the_queue->num_elements] = new_state;
the_queue->num_elements++;
/* Fix up priority queue */
index = the_queue->num_elements;
while (index > 1 && get_parent_value(the_queue, index) > new_state->utility)
{
swap_entries(carmen_trunc(index/2), index, the_queue);
index = carmen_trunc(index/2);
}
}
static inline void lower_cost(int id, int parent_id, double cost,
double new_utility, queue state_queue)
{
int i;
for (i = 0; i < state_queue->num_elements; i++) {
if (state_queue->data_array[i]->id == id) {
state_queue->data_array[i]->parent_id = parent_id;
state_queue->data_array[i]->cost = cost;
state_queue->data_array[i]->utility = new_utility;
}
}
/* Fix up priority queue */
i = state_queue->num_elements;
while (i > 1 && get_parent_value(state_queue, i) > new_utility) {
swap_entries(carmen_trunc(i/2), i, state_queue);
i = carmen_trunc(i/2);
}
}
int
list_swap_values(linked_list_t *list, size_t pos1, size_t pos2)
{
return swap_entries(list, pos1, pos2);
}
DLLSYM inT32
choose_nth_item ( //fast median
inT32 index, //index to choose
void *array, //array of items
inT32 count, //no of items
size_t size, //element size
//comparator
int (*compar) (const void *, const void *)
) {
int result; //of compar
inT32 next_sample; //next one to do
inT32 next_lesser; //space for new
inT32 prev_greater; //last one saved
inT32 equal_count; //no of equal ones
inT32 pivot; //proposed median
if (count <= 1)
return 0;
if (count == 2) {
if (compar (array, (char *) array + size) < 0) {
return index >= 1 ? 1 : 0;
}
else {
return index >= 1 ? 0 : 1;
}
}
if (index < 0)
index = 0; //ensure lergal
else if (index >= count)
index = count - 1;
pivot = (inT32) (rand () % count);
swap_entries (array, size, pivot, 0);
next_lesser = 0;
prev_greater = count;
equal_count = 1;
for (next_sample = 1; next_sample < prev_greater;) {
result =
compar ((char *) array + size * next_sample,
(char *) array + size * next_lesser);
if (result < 0) {
swap_entries (array, size, next_lesser++, next_sample++);
//shuffle
}
else if (result > 0) {
prev_greater--;
swap_entries(array, size, prev_greater, next_sample);
}
else {
equal_count++;
next_sample++;
}
}
if (index < next_lesser)
return choose_nth_item (index, array, next_lesser, size, compar);
else if (index < prev_greater)
return next_lesser; //in equal bracket
else
return choose_nth_item (index - prev_greater,
(char *) array + size * prev_greater,
count - prev_greater, size,
compar) + prev_greater;
}
