zlib compress testing...

begin...



#ifndef __DKUTIL_ALGORITHM_INCLUDE_ONCE__
#define __DKUTIL_ALGORITHM_INCLUDE_ONCE__

/*!
@auther d
@note
<h2>Ql@TCg,</h2>
<ul>
<li>F ́wCɂŐVASYTx
<li> Ã΃ǃЃуŃʃ 
<a href="http://www.s34.co.jp/cpptechdoc/">C++@Technical Documents</a><br>
http://www.s34.co.jp/cpptechdoc/article/sort/index.html#4<br>
<li>NUTS <a href="http://www2s.biglobe.ne.jp/~nuts/">B-con</a> -> Laboratory<br>
</ul>

<br>
<h2>\̂</h2>
<ul>
<li>mps  (Multi Partition Sort) :<br>
NCbN\[g1.5{(dׂ)\[g
QlTCg:Ao܂ASTLΉŎĉB_(._.)_yR
http://www.tokuyama.ac.jp/home/~kawamura/
<li>stableȃ\[eBOASƂ
<li>^CpbȟłȈÍ́H
<li>Hasher:
MD5 Hash,̑Ahash_mapɎĝƂB<br>
(hasher͂`킩B@g@!!(*KtK)_^(*KK)Eqb!!@  )<br>
</ul>
*/





#include "../global.h"
#include "../math/math_allinclude.h"//dKingyoRandom.h"

namespace dkutil{//begin dkutil namespace


template<class V = std::vector<BYTE> >
class RunLengthBase{
	V mv;
public:
	typedef V::iterator iterator;
	typedef V VECTOR_TYPE;
	RunLengthBase(){}
	virtual ~RunLengthBase(){}
	int Compress(BYTE *data,size_t size,int bits)
	{
		size_t i=0;
		size_t counter = 0;

		if(data==NULL || size==0){
			return edk_LogicError;//Az͂قƂ
		}
		
		//Ƃ
		mv.clear();


		if(bits == 8){	//RunLength 8 bits/pixel
			BYTE temp = data[0];
			counter = 1;//݂ĂP
			//loop
			for(i=1;i<size;i++){
				if(temp==255){
					temp =temp;
				}
				if(data[i] == temp && counter != 255){
					counter++;
				}else{
					mv.push_back(temp);
					mv.push_back(counter);
					counter = 1;//݂ĂP
					temp = data[i];
					
				}
				if(size - 1 == i)
				{//Ō̂̂Ԃ
					mv.push_back(temp);
					mv.push_back(counter);
				}
			}
		}else{
			return edk_LogicError;
		}
		return edk_SUCCEEDED;
	}
	V &get_vector(){return mv;}
	int Extract(BYTE *data,size_t size,int bits){
		size_t i=0,j=0;
		if(data==NULL || size==0 || !(size % 2)){
			return edk_LogicError;//Az͂قƂ
		}
		mv.clear();

		if(bits == 8){	//RunLength 8 bits/pixel
			//loop
			for(i=0;i<size;i+=2){
				for(j = 0;j<data[i+1];j++){
					mv.push_back(data[i]);
				}
			}
		}else{
			return edk_LogicError;
		}
		return edk_SUCCEEDED;
	}
	void reserve_buff(size_t size){
		mv.reserve(size);
	}
};

typedef RunLengthBase<> RunLength;		


///דǋāOOG
#define inssort_macro(comparison) \
	{ \
		int i, j; \
		T x; \
		for (i = 1; i < n; i++) { \
			x = a[i]; \
			for (j = i - 1; j >= 0 && a[j] comparison x; j--) \
				a[j + 1] = a[j]; \
			a[j + 1] = x; \
		} \
	}


template<class T>
void inssort(int n, T *a)
{
	inssort_macro( > );
}

template<class T>
void inssort_reverse(int n, T *a)
{
	 inssort_macro( < );
}


#define THRESHOLD 10
#define STACKSIZE 32  /*  int ̃rbgx */


//DRAW_QUEUEpNCbN\[g
#define STACKSIZE 32 //X^bNTCYright leftL^炵
#define THRESHOLD 10//s()邩炵

/*!
ʂ̕ϐ\[gł܂B
C++IuWFNg(NX)\[gȂquicksort_object_macrogĂB
@param n[in] \[gz̐
@param a[in][out] \[gz̃|C^Ԃ
@param comparison rZq <͍~ > ͏
@param type ϐ̌^
@param next_sort NCbN\[gs\[gw肷@
*/

///דȃ\[g}N
#define quicksort_macro(n,a,comparison,TYPE,next_sort) \
{ \
	int i, j, left, right, p; \
	int leftstack[STACKSIZE], rightstack[STACKSIZE]; \
	TYPE x,t; \
	left = 0;  right = n - 1;  p = 0; \
	for ( ; ; ) { \
		if (right - left <= THRESHOLD) { \
				if (p == 0) break; \
				p--; \
				left = leftstack[p]; \
				right = rightstack[p]; \
		} \
		x = a[(left + right) / 2];\
		i = left;  j = right;\
		for ( ; ; ) { \
			while (a[i] comparison x) i++; \
			while (x comparison a[j]) j--; \
			if (i >= j) break; \
			t = a[i];  a[i] = a[j];  a[j] = t; \
			i++;  j--; \
		} \
		if (i - left > right - j) { \
			if (i - left > THRESHOLD) { \
				leftstack[p] = left; \
				rightstack[p] = i - 1; \
				p++; \
			} \
			left = j + 1; \
		} else { \
			if (right - j > THRESHOLD) { \
					leftstack[p] = j + 1; \
					rightstack[p] = right; \
					p++; \
			} \
			right = i - 1; \
		} \
	} \
	next_sort<TYPE>(n, a); \
}



template<typename T>
void quicksort(int n, T *a)
{
	quicksort_macro(n,a, <,T, inssort );
}


template<typename T>
void quicksort_reverse(int n, T *a)
{
	quicksort_macro(n,a ,> ,T,inssort_reverse);
}


///דȃ\[g}N quicksort_macroƓ
#define quicksort_object_macro(n,a,comparison,TYPE,next_sort) \
{ \
	int i, j, left, right, p; \
	int leftstack[STACKSIZE], rightstack[STACKSIZE]; \
	int x;/*quicksort_macorƈႤ*/\
	TYPE t; \
	left = 0;  right = n - 1;  p = 0; \
	for ( ; ; ) { \
		if (right - left <= THRESHOLD) { \
				if (p == 0) break; \
				p--; \
				left = leftstack[p]; \
				right = rightstack[p]; \
		} \
		x = n/2;/*quicksort_macorƈႤ*/\
		i = left;  j = right;\
		for ( ; ; ) { \
			while (a[i] comparison x) i++; \
			while (x comparison a[j]) j--; \
			if (i >= j) break; \
			t = a[i];  a[i] = a[j];  a[j] = t; \
			i++;  j--; \
		} \
		if (i - left > right - j) { \
			if (i - left > THRESHOLD) { \
				leftstack[p] = left; \
				rightstack[p] = i - 1; \
				p++; \
			} \
			left = j + 1; \
		} else { \
			if (right - j > THRESHOLD) { \
					leftstack[p] = j + 1; \
					rightstack[p] = right; \
					p++; \
			} \
			right = i - 1; \
		} \
	} \
	next_sort<TYPE>(n, a); \
}

template<class T>
void quicksort_object(int n,T *obj){
	quicksort_object_macro(n,obj, < , T ,inssort);
}

template<class T>
void quicksort_object_reverse(int n,T *obj){
	quicksort_object_macro(n,obj,>,T,inssort_reverse);
}



template<class T,class COMP>
void shellsort_base(int n, T *a)  /* a[0..n-1]  */
{
	int h, i, j;
	T x;
	COMP cmp;
	h = 13;
	while (h < n) h = 3 * h + 1;
	h /= 9;
	while (h > 0) {
		for (i = h; i < n; i++) {
			x = a[i];
			for (j = i - h; j >= 0 && cmp(a[j] , x); j -= h)
				a[j + h] = a[j];
			a[j + h] = x;
		}
		h /= 3;
	}
}




	

/*!
h=n/1.3Ƃ 
ԊuhĎof[^Ƀou\[gKp 
h=h/1.3ƂA2.JԂB 
h=1ɂȂAŌɃou\[gKpďI 


ou\[g͗אڂ (1 ꂽ) vfԂŔrEsA
R\[g n ꂽvfԂŔrEsB
n  vf菬Cӂ̐n܂āA
i =   ni = 1 ƂȂBۂɂ n1 = vf - 1A
ni+1 = ni / 1.3 肪ǂ炵B
ł n = ( n * 10 + 3 ) / 13 ƂāA
_ZƋɁA +3  n = 0 ƂȂ̂Sɖh@pB 

*/
template<class T,class C >
void combsort_base(int n,T *data)
{
  int i,gap,swap;
	T w;
	C comp;
  for(gap = n,swap = 1;(gap > 1) || swap;){
    gap = (gap * 10 + 3) / 13;
    if(gap == 9 || gap == 10)
        gap = 11;
    swap = 0;
    for(i = 0; i < n - gap; i++){
      if( comp(data[i] , data[i + gap]) ){
          w = data[i]; data[i] = data[i + gap]; data[i + gap] = w;
          swap = 1;
      }
    }
  }
}






/*
//ŃG[oȂftHgׂ͂B
template<typename T,class FUNC=inssort<T>,class REVERSE_FUNC=inssort_reverse<T> >
struct sort_setup{
	void quicksort(int n,T *a,bool reverseflag){
		if(reverseflag){
			quicksort_macro(n,a ,> ,T,REVERSE_FUNC);
		}else{
			quicksort_macro(n,a, <,T, FUNC );
		}
	}
};
*/

template<class T,class COMP=std::greater<T> >
struct sorter{
	void comb_sort(int n,T *p){
		combsort_base<T,COMP>(n,p);
	}
	void shell_sort(int n,T *p){
		shellsort_base<T,COMP>(n,p);
	}
};



}//end of dkutil namespace


#endif //end of __DKUTIL_ALGORITHM_INCLUDE_ONCE__







...end