ccstruct/statistc.h File Reference

#include <stdio.h>
#include "grphics.h"

Go to the source code of this file.

Classes

• class STATS

  Statistics package. More...
  

Functions

• DLLSYM INT32 choose_nth_item (INT32 index, void *array, INT32 count, size_t size, int(*compar)(const void *, const void *))

  Returns the index of what would b the nth item in the array if the members were sorted, without actually sorting.
  

• DLLSYM INT32 choose_nth_item (INT32 index, float *array, INT32 count)

  Fast median.
  

• void swap_entries (void *array, size_t size, INT32 index1, INT32 index2)

  Swap 2 entries of abitrary size in-place in a table.
  

---

Function Documentation

DLLSYM INT32 choose_nth_item	(	INT32	index,
		void *	array,
		INT32	count,
		size_t	size,
		int(*)(const void *, const void *)	compar
	)

Returns the index of what would b the nth item in the array if the members were sorted, without actually sorting.

Definition at line 766 of file statistc.cpp.

References choose_nth_item(), nrand48(), SEED1, SEED2, SEED3, and swap_entries().

  {
  static UINT16 seeds[3] = { SEED1, SEED2, SEED3 };
  //for nrand
  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;
  #ifdef __UNIX__
  pivot = (INT32) (nrand48 (seeds) % count);
  #else
  pivot = (INT32) (rand () % count);
  #endif
  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;
}

DLLSYM INT32 choose_nth_item	(	INT32	index,
		float *	array,
		INT32	count
	)

Fast median.

Parameters:

	index	index to choose
	array	array of items
	count	number of items

Returns the index of what would b the nth item in the array if the members were sorted, without actually sorting.

next one to do

space for new

last one saved

no of equal ones

proposed median

current sample

in equal bracket

Definition at line 692 of file statistc.cpp.

References choose_nth_item(), nrand48(), SEED1, SEED2, and SEED3.

                              {
  static UINT16 seeds[3] = { SEED1, SEED2, SEED3 };
  //for nrand
  INT32 next_sample;             
  INT32 next_lesser;             
  INT32 prev_greater;            
  INT32 equal_count;             
  float pivot;                   
  float sample;                  

  if (count <= 1)
    return 0;
  if (count == 2) {
    if (array[0] < array[1]) {
      return index >= 1 ? 1 : 0;
    }
    else {
      return index >= 1 ? 0 : 1;
    }
  }
  else {
    if (index < 0)
      index = 0;                 // ensure lergal
    else if (index >= count)
      index = count - 1;
    #ifdef __UNIX__
    equal_count = (INT32) (nrand48 (seeds) % count);
    #else
    equal_count = (INT32) (rand () % count);
    #endif
    pivot = array[equal_count];
    array[equal_count] = array[0]; // fill gap
    next_lesser = 0;
    prev_greater = count;
    equal_count = 1;
    for (next_sample = 1; next_sample < prev_greater;) {
      sample = array[next_sample];
      if (sample < pivot) {
        array[next_lesser++] = sample; // shuffle
        next_sample++;
      }
      else if (sample > pivot) {
        prev_greater--;
        array[next_sample] = array[prev_greater]; // juggle
        array[prev_greater] = sample;
      }
      else {
        equal_count++;
        next_sample++;
      }
    }
    for (next_sample = next_lesser; next_sample < prev_greater;)
      array[next_sample++] = pivot;
    if (index < next_lesser)
      return choose_nth_item (index, array, next_lesser);
    else if (index < prev_greater)
      return next_lesser;        
    else
      return choose_nth_item (index - prev_greater,
        array + prev_greater,
        count - prev_greater) + prev_greater;
  }
}

void swap_entries	(	void *	array,
		size_t	size,
		INT32	index1,
		INT32	index2
	)

Swap 2 entries of abitrary size in-place in a table.

Definition at line 838 of file statistc.cpp.

Referenced by choose_nth_item().

                                {
  char tmp;
  char *ptr1;                    //to entries
  char *ptr2;
  size_t count;                  //of bytes

  ptr1 = (char *) array + index1 * size;
  ptr2 = (char *) array + index2 * size;
  for (count = 0; count < size; count++) {
    tmp = *ptr1;
    *ptr1++ = *ptr2;
    *ptr2++ = tmp;               //tedious!
  }
}

---