解説クラスＣｏｐｙＣｌｅａｒ（１９）
解説クラスＣｏｐｙＣｌｅａｒ（１９）
２０２５年１月２４初講（初稿）
【ソーティング応用】系の関数の解説を行います！
この講義は解説『解説クラスＣｏｐｙＣｌｅａｒ（１８）』
の続きです！
（４－１４－６５）関数「void SortArea(int sw,TypeSf bufS[],int size){・・・｝」
/************************************************************************/
/***** ＱＵＩＣ－ＳＯＲＴ：単純ソート：データ＝TypeSfで面積 *****/
/************************************************************************/
void CopyClear::SortArea(
int sw, // 0:昇順、 1:降順
TypeSf bufS[], // バッファー
int size // バッファーサイズ
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortAreaTypeSf0( bufS, &bufS[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortAreaTypeSf1( bufS, &bufS[ size - 1 ] ); // 降順ソートを行う
} //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortArea()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
「Area」は、「面⇒面積」を意味します！この関数は、
仮引数「TypeSf bufS[],」の型「TypeSf」と
「幾何図形計測型」≪解説『解説クラスＴｙｐｅＳｆ』の
中で説明？！★備考★２０２２年１２月２３記載時は、まだ
解説文章は、未発表≫
データのソート対象一次元配列！の面積成分をキーとして
データをソーティングする関数です！
（Ｂ）関数「void SortArea()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「SortArea()」の【仮引数】
void CopyClear::SortArea(
int sw, // 0:昇順、 1:降順
TypeSf bufS[], // バッファー
int size // バッファーサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「TypeSf bufS[],」は、「TypeSf 型」と
仮引数「TypeSf bufS[],」の型「TypeSf」と
「幾何図形計測型」≪解説『解説クラスＴｙｐｅＳｆ』の
中で説明？！
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「SortArea()」の【アルゴリズム】
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortAreaTypeSf0( bufS, &bufS[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortAreaTypeSf1( bufS, &bufS[ size - 1 ] ); // 降順ソートを行う
} //
}「if(size<=0){return;}」は、仮引数「int size」が、
０以下なら、無処理！
「if(sw==0){sortAreaTypeSf0(bufS,&bufS[size-1]);}」は、
条件「sw==0」、条件成立＝昇順ソートなら、
中身「sortAreaTypeSf0(bufS,&bufS[size-1]);」と
サブルーチン関数「sortAreaTypeSf0()」で処理！
条件不成立＝降順ソートなら、
中身「sortAreaTypeSf1(bufS,&bufS[size-1]);」と
サブルーチン関数「sortAreaTypeSf1()」で処理！
☆備考☆解説編集の都合で実際に処理するサブルーチン関数
「sortAreaTypeSf0()」・「sortAreaTypeSf1()」の説明は、
恐らく、この解説文章で無く「private:」属性の関数の
解説で記載しますので後回しに成ります！★注意★
アルゴリズム的には、ソートアルゴリズムの定番で有る
「クイック・ソート」を使用しています！
（４－１４－６６）関数「void SortArea(int sw,TypeMB bufM[],int size){・・・｝」
/************************************************************************/
/***** ＱＵＩＣ－ＳＯＲＴ：単純ソート：データ＝TypeMBで面積 *****/
/************************************************************************/
void CopyClear::SortArea(
int sw, // 0:昇順、 1:降順
TypeMB bufM[], // バッファー
int size // バッファーサイズ
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortAreaTypeMB0( bufM, &bufM[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortAreaTypeMB1( bufM, &bufM[ size - 1 ] ); // 降順ソートを行う
} //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortArea()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
「Area」は、「面⇒面積」を意味します！この関数は、
仮引数「TypeMB bufM[],」の型「TypeMB」と
「幾何図形計測型」≪解説『解説クラスＴｙｐｅＳｆ』の
中で説明？！★備考★２０２２年１２月２３記載時は、まだ
解説文章は、未発表≫
データのソート対象一次元配列！の面積成分をキーとして
データをソーティングする関数です！
（Ｂ）関数「void SortArea()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「SortArea()」の【仮引数】
void CopyClear::SortArea(
int sw, // 0:昇順、 1:降順
TypeMB bufM[], // バッファー
int size // バッファーサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「TypeMB bufM[],」は、「TypeMB 型」と
「幾何図形計測型」≪解説『解説クラスＴｙｐｅＳｆ』の
中で説明？！
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「SortArea()」の【アルゴリズム】
){
if( size <= 0 ){ // サイズが０以下
return; // 即終了
} //
if( sw == 0 ){ // 昇順ソートなら
sortAreaTypeMB0( bufM, &bufM[ size - 1 ] ); // 昇順ソートを行う
}else{ // 降順ソートなら
sortAreaTypeMB1( bufM, &bufM[ size - 1 ] ); // 降順ソートを行う
} //
}「if(size<=0){return;}」は、仮引数「int size」が、
０以下なら、無処理！
「if(sw==0){sortAreaTypeMB0(bufM,&bufM[size-1]);}」は、
条件「sw==0」、条件成立＝昇順ソートなら、
中身「sortAreaTypeMB0(bufM,&bufM[size-1]);」と
サブルーチン関数「sortAreaTypeMB0()」で処理！
条件不成立＝降順ソートなら、
中身「sortAreaTypeMB1(bufM,&bufM[size-1]);」と
サブルーチン関数「sortAreaTypeMB1()」で処理！
☆備考☆解説編集の都合で実際に処理するサブルーチン関数
「sortAreaTypeMB0()」・「sortAreaTypeMB1()」の説明は、
恐らく、この解説文章で無く「private:」属性の関数の
解説で記載しますので後回しに成ります！★注意★
アルゴリズム的には、ソートアルゴリズムの定番で有る
「クイック・ソート」を使用しています！
（４－１４－６７）関数「int SortIndex(int sw,
BYTE bufkey[],short bufix[],
int size){・・・｝」
/************************************************************************/
/***** ＱＵＩＣ－ＳＯＲＴ：キー付きソート：データ＝８bits *****/
/************************************************************************/
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
BYTE bufkey[], // キー部のバッファー
short bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){
TypeSort *buf; // KeySort用Buffer
TypeSort *ptr; // 上記Ptr
BYTE *ptrkey; // キー部Ptr
short *ptrix; // 添字部Ptr
int i; // 添字部用初期値Cunt
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
buf = (TypeSort*)malloc( sizeof(TypeSort) // Bufferを確保
* ( size + 10 ) ); //
if( buf == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptrkey = bufkey; // キー部と内部Bufferの
ptr = buf; // PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
ptr->key = *ptrkey++; // キーDataを格納し
ptr->ix = i; // 初期値添字を設定する
ptr++; // Bufferを１つ進める
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_key( buf, &buf[ size - 1 ] ); // 昇順キーソートを行う
}else{ // 降順キーソートなら
sort_key_rev( buf, &buf[ size - 1 ] ); // 降順キーソートを行う
} //
ptrkey = bufkey; // キー部と添字部と
ptrix = bufix; // 内部Bufferの
ptr = buf; // PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptrkey++ = (BYTE)ptr->key; // キーデータを再設定し
*ptrix++ = ptr->ix; // 添字データを設定する
ptr++; // Bufferを１つ進める
} //
free( buf ); // Bufferを解放し
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortIndex()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
「Index」は、英語「index」≒索引、カタカナ語でも
インデックス、ココでは、ソート対象のキー配列に連動して
順番が、インデックスも入れ替わる事で別の関連するデータ
構造を並び替える為の補助に使用するための関数です！
（Ｂ）関数「int SortIndex()」の【返値】
正常終了≪ソートサイズが０以下の場合、詰り、処理出来無
かった場合も含む≫は、辺値「END_STI」を返し、内部で
メモリ確保を行う事に失敗した場合は、エラーコード「
STI_MEM」を返します！
（Ｃ）関数「SortIndex()」の【仮引数】
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
BYTE bufkey[], // キー部のバッファー
short bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「BYTE bufkey[],」は、ソート対象のキー配列です！
今回は「BYTE型＝unsigned char型」と１バイト符号無し！
「short bufix[], 」は、キー配列に連動して並び替えラレル
インデックス配列です！★注意★この関数の実行で初めて
インデックス値が、セット去れます！予めデータをセットし
ても新規に内部でセットした値に置き換わります！
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「SortIndex()」の【アルゴリズム】
){
TypeSort *buf; // KeySort用Buffer
TypeSort *ptr; // 上記Ptr
BYTE *ptrkey; // キー部Ptr
short *ptrix; // 添字部Ptr
int i; // 添字部用初期値Cunt
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
buf = (TypeSort*)malloc( sizeof(TypeSort) // Bufferを確保
* ( size + 10 ) ); //
if( buf == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptrkey = bufkey; // キー部と内部Bufferの
ptr = buf; // PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
ptr->key = *ptrkey++; // キーDataを格納し
ptr->ix = i; // 初期値添字を設定する
ptr++; // Bufferを１つ進める
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_key( buf, &buf[ size - 1 ] ); // 昇順キーソートを行う
}else{ // 降順キーソートなら
sort_key_rev( buf, &buf[ size - 1 ] ); // 降順キーソートを行う
} //
ptrkey = bufkey; // キー部と添字部と
ptrix = bufix; // 内部Bufferの
ptr = buf; // PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptrkey++ = (BYTE)ptr->key; // キーデータを再設定し
*ptrix++ = ptr->ix; // 添字データを設定する
ptr++; // Bufferを１つ進める
} //
free( buf ); // Bufferを解放し
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
TypeSort *buf; // KeySort用Buffer
TypeSort *ptr; // 上記Ptr
BYTE *ptrkey; // キー部Ptr
short *ptrix; // 添字部Ptr
int i; // 添字部用初期値Cunt「TypeSort* buf;TypeSort* ptr;」は、ここで使用する専用
の型「TypeSort」≪解説『解説クラスＣｏｐｙＣｌｅａｒ（
１）』の「（３）クラス内ローカル構造体定義」で解説≫の
メモリ確保用の「buf」と操作用の「ptr」です！
「BYTE ptrkey;」は、仮引数「BYTE bufkey[],」の操作用！
「short ptrix;」は、仮引数「BYTE bufix[],」の操作用！
「int i;」は、ループカウンタ及び添字（インデックス）
の値！
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
buf = (TypeSort*)malloc( sizeof(TypeSort) // Bufferを確保
* ( size + 10 ) ); //
if( buf == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptrkey = bufkey; // キー部と内部Bufferの
ptr = buf; // PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
ptr->key = *ptrkey++; // キーDataを格納し
ptr->ix = i; // 初期値添字を設定する
ptr++; // Bufferを１つ進める
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_key( buf, &buf[ size - 1 ] ); // 昇順キーソートを行う
}else{ // 降順キーソートなら
sort_key_rev( buf, &buf[ size - 1 ] ); // 降順キーソートを行う
} //
ptrkey = bufkey; // キー部と添字部と
ptrix = bufix; // 内部Bufferの
ptr = buf; // PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptrkey++ = (BYTE)ptr->key; // キーデータを再設定し
*ptrix++ = ptr->ix; // 添字データを設定する
ptr++; // Bufferを１つ進める
} //
free( buf ); // Bufferを解放し
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「buf=(TypeSort*)malloc(sizeof(TypeSort)(size+10));
」は、内部で使用する型「TypeSort」のバッファ用メモリ
確保です！
「if(buf==0){return(STI_MEM);}」は、条件「buf==0」
詰り、メモリ確保失敗時⇒「return(STI_MEM);」と辺値
［STI_MEM］をメモリ確保失敗を示すエラーコードとして
関数辺値とし返し関数終了！
「ptrkey=bufkey;ptr=buf;」は仮引数「BYTE bufkey[],」
を操作用のポインタ「BYTE ptrkey;」にセットし、内部で
取得した「TypeSort* buf;」を操作用のポインタ
「TypeSort* ptr;」にセット！
「for(i=0;i<size;i++){ptr->key=ptrkey++;ptr->ix=i;
ptr++;}」は、お馴染みのｆｏｒループ構文
「for(i=0;i<size;i++){・・中身・・}」でループカウン
タ「i」が「0」から「size-1」まで繰り返し、中身
「ptr->key=ptrkey++;ptr->ix=i;ptr++;」で内部使用
バッファ「TypeSort buf;」のキー部「->key」に仮引数
「BYTE bufkey[],」のキー配列データコピーし、インデッ
クス部には、「ptr->ix=i;」とループカウンタの値を昇順
にインクリメントパターンとしてセットします！
「if(sw==0){sort_key(buf,&buf[size-1]);}」は、条件「sw==0」
詰り、昇順ソート時成立でサブルーチン関数
「sort_key(buf,&buf[size-1]);」で内部バッファをソート
「else{sort_key_rev(buf,&buf[size-1]);}」は、不成立＝
降順ソート時成立でサブルーチン関数
「sort_key_rev(buf,&buf[size-1]);」で内部バッファをソート
「ptrkey=bufkey;ptrix=bufix;ptr=buf;」は、
仮引数「BYTE bufkey[],」を操作用のポインタ
「BYTE ptrkey;」にセットし、仮引数「short bufix[], 」
を操作用のポインタ「short ptrix;」にセットし、内部で
取得した「TypeSort buf;」を操作用のポインタ
「TypeSort* ptr;」にセット！
「for(i=0;i<size;i++){*ptrkey++=(BYTE)ptr->key;
*ptrix++=ptr->ix;ptr++;}」は、お馴染みのｆｏｒループ
構文「for(i=0;i<size;i++){・・中身・・}」でループカウ
ンタ「i」が「0」から「size-1」まで繰り返し、中身「
*ptrkey++=(BYTE)ptr->key;*ptrix++=ptr->ix;ptr++;」と
既にソートした内部バッファのキー部「ptr->key」を
仮引数「BYTE bufkey[],」にコピーし、インデックス部「
ptr->ix」を仮引数「short bufix[], 」にコピー！
「free(buf);return(END_STI);」は、内部バッファとして
確保したメモリを解放し、正常終了を返し関数終了！
（４－１４－６８）関数「int SortIndex(int sw,
short bufkey[],short bufix[],
int size){・・・｝」
/************************************************************************/
/***** ＳＯＲＴ： キー付き：１６ビット *****/
/************************************************************************/
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
short bufkey[], // キー部のバッファー
short bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){
TypeSort *buf; // KeySort用Buffer
TypeSort *ptr; // 上記Ptr
short *ptrkey; // キー部Ptr
short *ptrix; // 添字部Ptr
int i; // 添字部用初期値Cunt
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
buf = (TypeSort*)malloc( sizeof(TypeSort) // Bufferを確保
* ( size + 10 ) ); //
if( buf == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptrkey = bufkey; // キー部と内部Bufferの
ptr = buf; // PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
ptr->key = *ptrkey++; // キーDataを格納し
ptr->ix = i; // 初期値添字を設定する
ptr++; // Bufferを１つ進める
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_key( buf, &buf[ size - 1 ] ); // 昇順キーソートを行う
}else{ // 降順キーソートなら
sort_key_rev( buf, &buf[ size - 1 ] ); // 降順キーソートを行う
} //
ptrkey = bufkey; // キー部と添字部と
ptrix = bufix; // 内部Bufferの
ptr = buf; // PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptrkey++ = ptr->key; // キーデータを再設定し
*ptrix++ = ptr->ix; // 添字データを設定する
ptr++; // Bufferを１つ進める
} //
free( buf ); // Bufferを解放し
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortIndex()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
「Index」は、英語「index」≒索引、カタカナ語でも
インデックス、ココでは、ソート対象のキー配列に連動して
順番が、インデックスも入れ替わる事で別の関連するデータ
構造を並び替える為の補助に使用するための関数です！
（Ｂ）関数「int SortIndex()」の【返値】
正常終了≪ソートサイズが０以下の場合、詰り、処理出来無
かった場合も含む≫は、辺値「END_STI」を返し、内部で
メモリ確保を行う事に失敗した場合は、エラーコード「
STI_MEM」を返します！
（Ｃ）関数「SortIndex()」の【仮引数】
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
short bufkey[], // キー部のバッファー
short bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「short bufkey[],」は、ソート対象のキー配列です！
今回は「short型」と２バイト符号有り！
「short bufix[], 」は、キー配列に連動して並び替えラレル
インデックス配列です！★注意★この関数の実行で初めて
インデックス値が、セット去れます！予めデータをセットし
ても新規に内部でセットした値に置き換わります！
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「SortIndex()」の【アルゴリズム】
){
TypeSort *buf; // KeySort用Buffer
TypeSort *ptr; // 上記Ptr
short *ptrkey; // キー部Ptr
short *ptrix; // 添字部Ptr
int i; // 添字部用初期値Cunt
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
buf = (TypeSort*)malloc( sizeof(TypeSort) // Bufferを確保
* ( size + 10 ) ); //
if( buf == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptrkey = bufkey; // キー部と内部Bufferの
ptr = buf; // PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
ptr->key = *ptrkey++; // キーDataを格納し
ptr->ix = i; // 初期値添字を設定する
ptr++; // Bufferを１つ進める
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_key( buf, &buf[ size - 1 ] ); // 昇順キーソートを行う
}else{ // 降順キーソートなら
sort_key_rev( buf, &buf[ size - 1 ] ); // 降順キーソートを行う
} //
ptrkey = bufkey; // キー部と添字部と
ptrix = bufix; // 内部Bufferの
ptr = buf; // PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptrkey++ = ptr->key; // キーデータを再設定し
*ptrix++ = ptr->ix; // 添字データを設定する
ptr++; // Bufferを１つ進める
} //
free( buf ); // Bufferを解放し
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
TypeSort *buf; // KeySort用Buffer
TypeSort *ptr; // 上記Ptr
short *ptrkey; // キー部Ptr
short *ptrix; // 添字部Ptr
int i; // 添字部用初期値Cunt「TypeSort* buf;TypeSort* ptr;」は、ここで使用する専用
の型「TypeSort」≪解説『解説クラスＣｏｐｙＣｌｅａｒ（
１）』の「（３）クラス内ローカル構造体定義」で解説≫の
メモリ確保用の「buf」と操作用の「ptr」です！
「short ptrkey;」は、仮引数「short bufkey[],」の操作用！
「short ptrix;」は、仮引数「short bufix[],」の操作用！
「int i;」は、ループカウンタ及び添字（インデックス）
の値！
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
buf = (TypeSort*)malloc( sizeof(TypeSort) // Bufferを確保
* ( size + 10 ) ); //
if( buf == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptrkey = bufkey; // キー部と内部Bufferの
ptr = buf; // PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
ptr->key = *ptrkey++; // キーDataを格納し
ptr->ix = i; // 初期値添字を設定する
ptr++; // Bufferを１つ進める
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_key( buf, &buf[ size - 1 ] ); // 昇順キーソートを行う
}else{ // 降順キーソートなら
sort_key_rev( buf, &buf[ size - 1 ] ); // 降順キーソートを行う
} //
ptrkey = bufkey; // キー部と添字部と
ptrix = bufix; // 内部Bufferの
ptr = buf; // PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptrkey++ = ptr->key; // キーデータを再設定し
*ptrix++ = ptr->ix; // 添字データを設定する
ptr++; // Bufferを１つ進める
} //
free( buf ); // Bufferを解放し
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「buf=(TypeSort*)malloc(sizeof(TypeSort)(size+10));
」は、内部で使用する型「TypeSort」のバッファ用メモリ
確保です！
「if(buf==0){return(STI_MEM);}」は、条件「buf==0」
詰り、メモリ確保失敗時⇒「return(STI_MEM);」と辺値
［STI_MEM］をメモリ確保失敗を示すエラーコードとして
関数辺値とし返し関数終了！
「ptrkey=bufkey;ptr=buf;」は仮引数「short bufkey[],」
を操作用のポインタ「short ptrkey;」にセットし、内部で
取得した「TypeSort* buf;」を操作用のポインタ
「TypeSort* ptr;」にセット！
「for(i=0;i<size;i++){ptr->key=ptrkey++;ptr->ix=i;
ptr++;}」は、お馴染みのｆｏｒループ構文
「for(i=0;i<size;i++){・・中身・・}」でループカウン
タ「i」が「0」から「size-1」まで繰り返し、中身
「ptr->key=ptrkey++;ptr->ix=i;ptr++;」で内部使用
バッファ「TypeSort buf;」のキー部「->key」に仮引数
「short bufkey[],」のキー配列データコピーし、インデッ
クス部には、「ptr->ix=i;」とループカウンタの値を昇順
にインクリメントパターンとしてセットします！
「if(sw==0){sort_key(buf,&buf[size-1]);}」は、条件「sw==0」
詰り、昇順ソート時成立でサブルーチン関数
「sort_key(buf,&buf[size-1]);」で内部バッファをソート
「else{sort_key_rev(buf,&buf[size-1]);}」は、不成立＝
降順ソート時成立でサブルーチン関数
「sort_key_rev(buf,&buf[size-1]);」で内部バッファをソート
「ptrkey=bufkey;ptrix=bufix;ptr=buf;」は、
仮引数「short bufkey[],」を操作用のポインタ
「short ptrkey;」にセットし、仮引数「short bufix[], 」
を操作用のポインタ「short ptrix;」にセットし、内部で
取得した「TypeSort buf;」を操作用のポインタ
「TypeSort* ptr;」にセット！
「for(i=0;i<size;i++){*ptrkey++=(short)ptr->key;
*ptrix++=ptr->ix;ptr++;}」は、お馴染みのｆｏｒループ
構文「for(i=0;i<size;i++){・・中身・・}」でループカウ
ンタ「i」が「0」から「size-1」まで繰り返し、中身「
*ptrkey++=(short)ptr->key;*ptrix++=ptr->ix;ptr++;」と
既にソートした内部バッファのキー部「ptr->key」を
仮引数「short bufkey[],」にコピーし、インデックス部「
ptr->ix」を仮引数「short bufix[], 」にコピー！
「free(buf);return(END_STI);」は、内部バッファとして
確保したメモリを解放し、正常終了を返し関数終了！
（４－１４－６９）関数「int SortIndex(int sw,
long bufkey[],short bufix[],
int size){・・・｝」
/************************************************************************/
/***** ＳＯＲＴ： キー＝３２ビット、添字＝１６ビット *****/
/************************************************************************/
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
long bufkey[], // キー部のバッファー
short bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){
short *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_long_0_key( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_long_1_key( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortIndex()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
「Index」は、英語「index」≒索引、カタカナ語でも
インデックス、ココでは、ソート対象のキー配列に連動して
順番が、インデックスも入れ替わる事で別の関連するデータ
構造を並び替える為の補助に使用するための関数です！
（Ｂ）関数「int SortIndex()」の【返値】
正常終了≪ソートサイズが０以下の場合、詰り、処理出来無
かった場合も含む≫は、辺値「END_STI」を返し、内部で
エラーが発生した場合を記載シヨウとしたが実際にはメモリ
確保を行う方法から変更したので常に辺値「END_STI」を返
し正常終了します！
（Ｃ）関数「SortIndex()」の【仮引数】
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
long bufkey[], // キー部のバッファー
short bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「long bufkey[],」は、ソート対象のキー配列です！
今回は「long型」と４バイト符号有り！
「short bufix[], 」は、キー配列に連動して並び替えラレル
インデックス配列です！★注意★この関数の実行で初めて
インデックス値が、セット去れます！予めデータをセットし
ても新規に内部でセットした値に置き換わります！
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「SortIndex()」の【アルゴリズム】
){
short *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_long_0_key( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_long_1_key( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
short *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_long_0_key( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_long_1_key( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「ptr_ix=bufix;」は、インデックス配列への操作ポインタ
セット！
「for(i=0;i<size;i++){*ptr_ix++=i;}」は、ループカウン
タ「i」が「0」から「size-1」まで繰り返し、インデック
ス配列へループカウンタの値をセット！
「if(sw==0){sort_long_0_key(bufkey,&bufkey[size-1],
bufix,&bufix[size-1]);}」は、条件「sw==0」詰り、
昇順ソート時成立でサブルーチン関数
「sort_long_0_key(bufkey,&bufkey[size-1],bufix,
&bufix[size-1]);」でキー配列「bufkey」をソート！
「else{sort_long_1_key(bufkey,&bufkey[size-1],
bufix,&bufix[size-1]);}」は、不成立＝降順ソート時
成立でサブルーチン関数「sort_long_1_key(bufkey,
&bufkey[size-1],bufix,&bufix[size-1]);」で
キー配列「bufkey」をソート！
「return(END_STI);」は、辺値「END_STI」を返し正常終了！
（４－１４－７０）関数「int SortIndex(int sw,int bufkey[],
short bufix[],int size){・・・｝」
/************************************************************************/
/***** ＳＯＲＴ： キー＝３２ビット、添字＝１６ビット *****/
/************************************************************************/
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
int bufkey[], // キー部のバッファー
short bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){
return( SortIndex( sw, // long型で処理
(long*)bufkey, bufix, size ) ); //
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortIndex()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
「Index」は、英語「index」≒索引、カタカナ語でも
インデックス、ココでは、ソート対象のキー配列に連動して
順番が、インデックスも入れ替わる事で別の関連するデータ
構造を並び替える為の補助に使用するための関数です！
（Ｂ）関数「int SortIndex()」の【返値】
正常終了≪ソートサイズが０以下の場合、詰り、処理出来無
かった場合も含む≫は、辺値「END_STI」を返し、内部で
エラーが発生した場合を記載シヨウとしたが実際にはメモリ
確保を行う方法から変更したので常に辺値「END_STI」を返
し正常終了します！
（Ｃ）関数「SortIndex()」の【仮引数】
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
int bufkey[], // キー部のバッファー
short bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「int bufkey[],」は、ソート対象のキー配列です！
今回は「int型」と４バイト符号有り！
「short bufix[], 」は、キー配列に連動して並び替えラレル
インデックス配列です！★注意★この関数の実行で初めて
インデックス値が、セット去れます！予めデータをセットし
ても新規に内部でセットした値に置き換わります！
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「SortIndex()」の【アルゴリズム】
){
return( SortIndex( sw, // long型で処理
(long*)bufkey, bufix, size ) ); //
}「return(SortIndex(sw,(long*)bufkey,bufix,size));」は、
前記【「４－１４－６９）関数「SortIndex()」】の仮引数
「bufkey」を型変換「(long*)」して実行
（４－１４－７１）関数「int SortIndex(int sw,
float bufkey[],short bufix[],
int size){・・・｝」
/************************************************************************/
/***** ＳＯＲＴ： キー＝単精度実数、添字＝１６ビット *****/
/************************************************************************/
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
float bufkey[], // キー部のバッファー
short bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){
short *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_float_0_key( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_float_1_key( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortIndex()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
「Index」は、英語「index」≒索引、カタカナ語でも
インデックス、ココでは、ソート対象のキー配列に連動して
順番が、インデックスも入れ替わる事で別の関連するデータ
構造を並び替える為の補助に使用するための関数です！
（Ｂ）関数「int SortIndex()」の【返値】
正常終了≪ソートサイズが０以下の場合、詰り、処理出来無
かった場合も含む≫は、辺値「END_STI」を返し、内部で
エラーが発生した場合を記載シヨウとしたが実際にはメモリ
確保を行う方法から変更したので常に辺値「END_STI」を返
し正常終了します！
（Ｃ）関数「SortIndex()」の【仮引数】
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
float bufkey[], // キー部のバッファー
short bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「float bufkey[],」は、ソート対象のキー配列です！
今回は「float型」と４バイト単精度浮動小数型！
「short bufix[], 」は、キー配列に連動して並び替えラレル
インデックス配列です！★注意★この関数の実行で初めて
インデックス値が、セット去れます！予めデータをセットし
ても新規に内部でセットした値に置き換わります！
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「SortIndex()」の【アルゴリズム】
){
short *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_float_0_key( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_float_1_key( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
short *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt「short* ptr_ix;」は、インデックス配列への操作ポインタ
「int i;」は、ループカウンタ及び添字（インデックス）
の値！
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_float_0_key( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_float_1_key( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「ptr_ix=bufix;」は、インデックス配列への操作ポインタ
セット！
「for(i=0;i<size;i++){*ptr_ix++=i;}」は、ループカウン
タ「i」が「0」から「size-1」まで繰り返し、インデック
ス配列へループカウンタの値をセット！
「if(sw==0){sort_float_0_key(bufkey,&bufkey[size-1],
bufix,&bufix[size-1]);}」は、条件「sw==0」詰り、
昇順ソート時成立でサブルーチン関数
「sort_float_0_key(bufkey,&bufkey[size-1],bufix,
&bufix[size-1]);」でキー配列「bufkey」をソート！
「else{sort_float_1_key(bufkey,&bufkey[size-1],
bufix,&bufix[size-1]);}」は、不成立＝降順ソート時
成立でサブルーチン関数「sort_float_1_key(bufkey,
&bufkey[size-1],bufix,&bufix[size-1]);」で
キー配列「bufkey」をソート！
「return(END_STI);」は、辺値「END_STI」を返し正常終了！
（４－１４－７２）関数「int SortIndex(int sw,double bufkey[],
short bufix[],int size){・・・｝」
/************************************************************************/
/***** ＳＯＲＴ： キー＝倍精度実数、添字＝１６ビット *****/
/************************************************************************/
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
double bufkey[], // キー部のバッファー
short bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){
short *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_double_0_key( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_double_1_key( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
} //☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortIndex()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
「Index」は、英語「index」≒索引、カタカナ語でも
インデックス、ココでは、ソート対象のキー配列に連動して
順番が、インデックスも入れ替わる事で別の関連するデータ
構造を並び替える為の補助に使用するための関数です！
（Ｂ）関数「int SortIndex()」の【返値】
正常終了≪ソートサイズが０以下の場合、詰り、処理出来無
かった場合も含む≫は、辺値「END_STI」を返し、内部で
エラーが発生した場合を記載シヨウとしたが実際にはメモリ
確保を行う方法から変更したので常に辺値「END_STI」を返
し正常終了します！
（Ｃ）関数「SortIndex()」の【仮引数】
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
double bufkey[], // キー部のバッファー
short bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「double bufkey[],」は、ソート対象のキー配列です！
今回は「double型」と８バイト倍精度浮動小数型！
「short bufix[], 」は、キー配列に連動して並び替えラレル
インデックス配列です！★注意★この関数の実行で初めて
インデックス値が、セット去れます！予めデータをセットし
ても新規に内部でセットした値に置き換わります！
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「SortIndex()」の【アルゴリズム】
){
short *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_double_0_key( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_double_1_key( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
} //（Ｄ－１）ローカル変数
){
short *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt「short* ptr_ix;」は、インデックス配列への操作ポインタ
「int i;」は、ループカウンタ及び添字（インデックス）
の値！
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_double_0_key( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_double_1_key( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
} //「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「ptr_ix=bufix;」は、インデックス配列への操作ポインタ
セット！
「for(i=0;i<size;i++){*ptr_ix++=i;}」は、ループカウン
タ「i」が「0」から「size-1」まで繰り返し、インデック
ス配列へループカウンタの値をセット！
「if(sw==0){sort_double_0_key(bufkey,&bufkey[size-1],
bufix,&bufix[size-1]);}」は、条件「sw==0」詰り、
昇順ソート時成立でサブルーチン関数
「sort_double_0_key(bufkey,&bufkey[size-1],bufix,
&bufix[size-1]);」でキー配列「bufkey」をソート！
「else{sort_double_1_key(bufkey,&bufkey[size-1],
bufix,&bufix[size-1]);}」は、不成立＝降順ソート時
成立でサブルーチン関数「sort_double_1_key(bufkey,
&bufkey[size-1],bufix,&bufix[size-1]);」で
キー配列「bufkey」をソート！
「return(END_STI);」は、辺値「END_STI」を返し正常終了！
（４－１４－７３）関数「int SortIndex(int sw,__int64 bufkey[],
short bufix[],int size){・・・｝」
/************************************************************************/
/***** ＳＯＲＴ： キー＝64Bit整数実数、添字＝１６ビット *****/
/************************************************************************/
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
__int64 bufkey[], // キー部のバッファー
short bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){
short *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_int64_0_key( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_int64_1_key( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
} //☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortIndex()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
「Index」は、英語「index」≒索引、カタカナ語でも
インデックス、ココでは、ソート対象のキー配列に連動して
順番が、インデックスも入れ替わる事で別の関連するデータ
構造を並び替える為の補助に使用するための関数です！
（Ｂ）関数「int SortIndex()」の【返値】
正常終了≪ソートサイズが０以下の場合、詰り、処理出来無
かった場合も含む≫は、辺値「END_STI」を返し、内部で
エラーが発生した場合を記載シヨウとしたが実際にはメモリ
確保を行う方法から変更したので常に辺値「END_STI」を返
し正常終了します！
（Ｃ）関数「SortIndex()」の【仮引数】
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
__int64 bufkey[], // キー部のバッファー
short bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「__int64 bufkey[],」は、ソート対象のキー配列です！
今回は「__int64型」と８バイト整数型！
「short bufix[], 」は、キー配列に連動して並び替えラレル
インデックス配列です！★注意★この関数の実行で初めて
インデックス値が、セット去れます！予めデータをセットし
ても新規に内部でセットした値に置き換わります！
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「SortIndex()」の【アルゴリズム】
){
short *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_int64_0_key( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_int64_1_key( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
} //（Ｄ－１）ローカル変数
){
short *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt「short* ptr_ix;」は、インデックス配列への操作ポインタ
「int i;」は、ループカウンタ及び添字（インデックス）
の値！
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_int64_0_key( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_int64_1_key( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
} //「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「ptr_ix=bufix;」は、インデックス配列への操作ポインタ
セット！
「for(i=0;i<size;i++){*ptr_ix++=i;}」は、ループカウン
タ「i」が「0」から「size-1」まで繰り返し、インデック
ス配列へループカウンタの値をセット！
「if(sw==0){sort_int64_0_key(bufkey,&bufkey[size-1],
bufix,&bufix[size-1]);}」は、条件「sw==0」詰り、
昇順ソート時成立でサブルーチン関数
「sort_int64_0_key(bufkey,&bufkey[size-1],bufix,
&bufix[size-1]);」でキー配列「bufkey」をソート！
「else{sort_int64_1_key(bufkey,&bufkey[size-1],
bufix,&bufix[size-1]);}」は、不成立＝降順ソート時
成立でサブルーチン関数「sort_int64_1_key(bufkey,
&bufkey[size-1],bufix,&bufix[size-1]);」で
キー配列「bufkey」をソート！
「return(END_STI);」は、辺値「END_STI」を返し正常終了！
（４－１４－７４）関数「int SortIndex(int sw,BYTE bufkey[],
int bufix[],int size){・・・｝」
/************************************************************************/
/***** ＳＯＲＴ： キー＝８ビット、添字＝３２ビット *****/
/************************************************************************/
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
BYTE bufkey[], // キー部のバッファー
int bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){
int *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_byte_0_key_ext( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_byte_1_key_ext( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear120」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortIndex()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
「Index」は、英語「index」≒索引、カタカナ語でも
インデックス、ココでは、ソート対象のキー配列に連動して
順番が、インデックスも入れ替わる事で別の関連するデータ
構造を並び替える為の補助に使用するための関数です！
（Ｂ）関数「int SortIndex()」の【返値】
正常終了≪ソートサイズが０以下の場合、詰り、処理出来無
かった場合も含む≫は、辺値「END_STI」を返し、内部で
エラーが発生した場合を記載シヨウとしたが実際にはメモリ
確保を行う方法から変更したので常に辺値「END_STI」を返
し正常終了します！
（Ｃ）関数「SortIndex()」の【仮引数】
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
BYTE bufkey[], // キー部のバッファー
int bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「BYTE bufkey[],」は、ソート対象のキー配列です！
今回は「BYTE型＝unsigned char型」と１バイト符号無し！
「int bufix[], 」は、キー配列に連動して並び替えラレル
インデックス配列です！★注意★この関数の実行で初めて
インデックス値が、セット去れます！予めデータをセットし
ても新規に内部でセットした値に置き換わります！
★備考★「（４－１４－７４）」から、「int bufix[],」
と「（４－１４－７３）」までの「short bufix[], 」と
インデックス配列が「short型」から「int型」に変更した
関数です！☆注意☆これは、サイズが「short型」の場合、
３２７６７個まで使用可能で「int型」に変更で
２１４７４８３６４７個まで理論上可能≒実質的に無制限！
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「SortIndex()」の【アルゴリズム】
){
int *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_byte_0_key_ext( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_byte_1_key_ext( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
int *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt「int* ptr_ix;」は、インデックス配列への操作ポインタ
「int i;」は、ループカウンタ及び添字（インデックス）
の値！
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_byte_0_key_ext( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_byte_1_key_ext( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「ptr_ix=bufix;」は、インデックス配列への操作ポインタ
セット！
「for(i=0;i<size;i++){*ptr_ix++=i;}」は、ループカウン
タ「i」が「0」から「size-1」まで繰り返し、インデック
ス配列へループカウンタの値をセット！
「if(sw==0){sort_byte_0_key_ext(bufkey,&bufkey[size-1],
bufix,&bufix[size-1]);}」は、条件「sw==0」詰り、
昇順ソート時成立でサブルーチン関数
「sort_byte_0_key_ext(bufkey,&bufkey[size-1],bufix,
&bufix[size-1]);」でキー配列「bufkey」をソート！
「else{sort_byte_1_key_ext(bufkey,&bufkey[size-1],
bufix,&bufix[size-1]);}」は、不成立＝降順ソート時
成立でサブルーチン関数「sort_byte_1_key_ext(bufkey,
&bufkey[size-1],bufix,&bufix[size-1]);」で
キー配列「bufkey」をソート！
「return(END_STI);」は、辺値「END_STI」を返し正常終了！
（４－１４－７５）関数「int SortIndex(int sw,short bufkey[],
int bufix[],int size){・・・｝」
/************************************************************************/
/***** ＳＯＲＴ： キー＝１６ビット、添字＝３２ビット *****/
/************************************************************************/
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
short bufkey[], // キー部のバッファー
int bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){
int *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_short_0_key_ext( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_short_1_key_ext( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear120」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortIndex()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
「Index」は、英語「index」≒索引、カタカナ語でも
インデックス、ココでは、ソート対象のキー配列に連動して
順番が、インデックスも入れ替わる事で別の関連するデータ
構造を並び替える為の補助に使用するための関数です！
（Ｂ）関数「int SortIndex()」の【返値】
正常終了≪ソートサイズが０以下の場合、詰り、処理出来無
かった場合も含む≫は、辺値「END_STI」を返し、内部で
エラーが発生した場合を記載シヨウとしたが実際にはメモリ
確保を行う方法から変更したので常に辺値「END_STI」を返
し正常終了します！
（Ｃ）関数「SortIndex()」の【仮引数】
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
short bufkey[], // キー部のバッファー
int bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「short bufkey[],」は、ソート対象のキー配列です！
今回は「short型」と２バイト符号有り！
「int bufix[], 」は、キー配列に連動して並び替えラレル
インデックス配列です！★注意★この関数の実行で初めて
インデックス値が、セット去れます！予めデータをセットし
ても新規に内部でセットした値に置き換わります！
★備考★「（４－１４－７４）」から、「int bufix[],」
と「（４－１４－７３）」までの「short bufix[], 」と
インデックス配列が「short型」から「int型」に変更した
関数です！☆注意☆これは、サイズが「short型」の場合、
３２７６７個まで使用可能で「int型」に変更で
２１４７４８３６４７個まで理論上可能≒実質的に無制限！
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「SortIndex()」の【アルゴリズム】
){
int *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_short_0_key_ext( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_short_1_key_ext( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
int *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt「int* ptr_ix;」は、インデックス配列への操作ポインタ
「int i;」は、ループカウンタ及び添字（インデックス）
の値！
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_short_0_key_ext( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_short_1_key_ext( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「ptr_ix=bufix;」は、インデックス配列への操作ポインタ
セット！
「for(i=0;i<size;i++){*ptr_ix++=i;}」は、ループカウン
タ「i」が「0」から「size-1」まで繰り返し、インデック
ス配列へループカウンタの値をセット！
「if(sw==0){sort_short_0_key_ext(bufkey,&bufkey[size-1],
bufix,&bufix[size-1]);}」は、条件「sw==0」詰り、
昇順ソート時成立でサブルーチン関数
「sort_short_0_key_ext(bufkey,&bufkey[size-1],bufix,
&bufix[size-1]);」でキー配列「bufkey」をソート！
「else{sort_short_1_key_ext(bufkey,&bufkey[size-1],
bufix,&bufix[size-1]);}」は、不成立＝降順ソート時
成立でサブルーチン関数「sort_short_1_key_ext(bufkey,
&bufkey[size-1],bufix,&bufix[size-1]);」で
キー配列「bufkey」をソート！
「return(END_STI);」は、辺値「END_STI」を返し正常終了！
（４－１４－７６）関数「int SortIndex(int sw,
long bufkey[],int bufix[],
int size){・・・｝」
/************************************************************************/
/***** ＳＯＲＴ： キー＝３２ビット、添字＝３２ビット *****/
/************************************************************************/
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
long bufkey[], // キー部のバッファー
int bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){
int *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_long_0_key_ext( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_long_1_key_ext( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear120」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortIndex()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
「Index」は、英語「index」≒索引、カタカナ語でも
インデックス、ココでは、ソート対象のキー配列に連動して
順番が、インデックスも入れ替わる事で別の関連するデータ
構造を並び替える為の補助に使用するための関数です！
（Ｂ）関数「int SortIndex()」の【返値】
正常終了≪ソートサイズが０以下の場合、詰り、処理出来無
かった場合も含む≫は、辺値「END_STI」を返し、内部で
エラーが発生した場合を記載シヨウとしたが実際にはメモリ
確保を行う方法から変更したので常に辺値「END_STI」を返
し正常終了します！
（Ｃ）関数「SortIndex()」の【仮引数】
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
long bufkey[], // キー部のバッファー
int bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「long bufkey[],」は、ソート対象のキー配列です！
今回は「long型」と２バイト符号有り！
「int bufix[], 」は、キー配列に連動して並び替えラレル
インデックス配列です！★注意★この関数の実行で初めて
インデックス値が、セット去れます！予めデータをセットし
ても新規に内部でセットした値に置き換わります！
★備考★「（４－１４－７４）」から、「int bufix[],」
と「（４－１４－７３）」までの「short bufix[], 」と
インデックス配列が「short型」から「int型」に変更した
関数です！☆注意☆これは、サイズが「short型」の場合、
３２７６７個まで使用可能で「int型」に変更で
２１４７４８３６４７個まで理論上可能≒実質的に無制限！
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「SortIndex()」の【アルゴリズム】
){
int *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_long_0_key_ext( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_long_1_key_ext( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
int *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt「int* ptr_ix;」は、インデックス配列への操作ポインタ
「int i;」は、ループカウンタ及び添字（インデックス）
の値！
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_long_0_key_ext( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_long_1_key_ext( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「ptr_ix=bufix;」は、インデックス配列への操作ポインタ
セット！
「for(i=0;i<size;i++){*ptr_ix++=i;}」は、ループカウン
タ「i」が「0」から「size-1」まで繰り返し、インデック
ス配列へループカウンタの値をセット！
「if(sw==0){sort_long_0_key_ext(bufkey,&bufkey[size-1],
bufix,&bufix[size-1]);}」は、条件「sw==0」詰り、
昇順ソート時成立でサブルーチン関数
「sort_long_0_key_ext(bufkey,&bufkey[size-1],bufix,
&bufix[size-1]);」でキー配列「bufkey」をソート！
「else{sort_long_1_key_ext(bufkey,&bufkey[size-1],
bufix,&bufix[size-1]);}」は、不成立＝降順ソート時
成立でサブルーチン関数「sort_long_1_key_ext(bufkey,
&bufkey[size-1],bufix,&bufix[size-1]);」で
キー配列「bufkey」をソート！
「return(END_STI);」は、辺値「END_STI」を返し正常終了！
（４－１４－７７）関数「int SortIndex(int sw,
int bufkey[],int bufix[],int size){・・・｝」
/************************************************************************/
/***** ＳＯＲＴ： キー＝３２ビット、添字＝３２ビット *****/
/************************************************************************/
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
int bufkey[], // キー部のバッファー
int bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){
return( SortIndex( sw, // long型で処理
(long*)bufkey, bufix, size ) ); //
}☆備考☆この関数はファイル「CopyClear120」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortIndex()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
「Index」は、英語「index」≒索引、カタカナ語でも
インデックス、ココでは、ソート対象のキー配列に連動して
順番が、インデックスも入れ替わる事で別の関連するデータ
構造を並び替える為の補助に使用するための関数です！
（Ｂ）関数「int SortIndex()」の【返値】
正常終了≪ソートサイズが０以下の場合、詰り、処理出来無
かった場合も含む≫は、辺値「END_STI」を返し、内部で
エラーが発生した場合を記載シヨウとしたが実際にはメモリ
確保を行う方法から変更したので常に辺値「END_STI」を返
し正常終了します！
（Ｃ）関数「SortIndex()」の【仮引数】
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
int bufkey[], // キー部のバッファー
int bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「int bufkey[],」は、ソート対象のキー配列です！
今回は「int型」と２バイト符号有り！
「int bufix[], 」は、キー配列に連動して並び替えラレル
インデックス配列です！★注意★この関数の実行で初めて
インデックス値が、セット去れます！予めデータをセットし
ても新規に内部でセットした値に置き換わります！
★備考★「（４－１４－７３）」から、「int bufix[],」
と「（４－１４－７２）」までの「short bufix[], 」と
インデックス配列が「short型」から「int型」に変更した
関数です！☆注意☆これは、サイズが「short型」の場合、
３２７６７個まで使用可能で「int型」に変更で
２１４７４８３６４７個まで理論上可能≒実質的に無制限！
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「SortIndex()」の【アルゴリズム】
「return(SortIndex(sw,(long*)bufkey,bufix,size));」は、
前記【「４－１４－７６）関数「SortIndex()」】の仮引数
「bufkey」を型変換「(long*)」して実行
（４－１４－７８）関数「int SortIndex(int sw,float bufkey[],
int bufix[],int size){・・・｝」
/************************************************************************/
/***** ＳＯＲＴ： キー＝単精度実数、添字＝３２ビット *****/
/************************************************************************/
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
float bufkey[], // キー部のバッファー
int bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){
int *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_float_0_key_ext( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_float_1_key_ext( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear120」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortIndex()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
「Index」は、英語「index」≒索引、カタカナ語でも
インデックス、ココでは、ソート対象のキー配列に連動して
順番が、インデックスも入れ替わる事で別の関連するデータ
構造を並び替える為の補助に使用するための関数です！
（Ｂ）関数「int SortIndex()」の【返値】
正常終了≪ソートサイズが０以下の場合、詰り、処理出来無
かった場合も含む≫は、辺値「END_STI」を返し、内部で
エラーが発生した場合を記載シヨウとしたが実際にはメモリ
確保を行う方法から変更したので常に辺値「END_STI」を返
し正常終了します！
（Ｃ）関数「SortIndex()」の【仮引数】
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
float bufkey[], // キー部のバッファー
int bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「float bufkey[],」は、ソート対象のキー配列です！
今回は「float型」と４バイト単精度浮動小数型！
「int bufix[], 」は、キー配列に連動して並び替えラレル
インデックス配列です！★注意★この関数の実行で初めて
インデックス値が、セット去れます！予めデータをセットし
ても新規に内部でセットした値に置き換わります！
★備考★「（４－１４－７４）」から、「int bufix[],」
と「（４－１４－７３）」までの「short bufix[], 」と
インデックス配列が「short型」から「int型」に変更した
関数です！☆注意☆これは、サイズが「short型」の場合、
３２７６７個まで使用可能で「int型」に変更で
２１４７４８３６４７個まで理論上可能≒実質的に無制限！
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「SortIndex()」の【アルゴリズム】
){
int *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_float_0_key_ext( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_float_1_key_ext( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
int *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt「int* ptr_ix;」は、インデックス配列への操作ポインタ
「int i;」は、ループカウンタ及び添字（インデックス）
の値！
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_float_0_key_ext( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_float_1_key_ext( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「ptr_ix=bufix;」は、インデックス配列への操作ポインタ
セット！
「for(i=0;i<size;i++){*ptr_ix++=i;}」は、ループカウン
タ「i」が「0」から「size-1」まで繰り返し、インデック
ス配列へループカウンタの値をセット！
「if(sw==0){sort_float_0_key_ext(bufkey,&bufkey[size-1],
bufix,&bufix[size-1]);}」は、条件「sw==0」詰り、
昇順ソート時成立でサブルーチン関数
「sort_float_0_key_ext(bufkey,&bufkey[size-1],bufix,
&bufix[size-1]);」でキー配列「bufkey」をソート！
「else{sort_float_1_key_ext(bufkey,&bufkey[size-1],
bufix,&bufix[size-1]);}」は、不成立＝降順ソート時
成立でサブルーチン関数「sort_float_1_key_ext(bufkey,
&bufkey[size-1],bufix,&bufix[size-1]);」で
キー配列「bufkey」をソート！
「return(END_STI);」は、辺値「END_STI」を返し正常終了！
（４－１４－７９）関数「int SortIndex(int sw,
double bufkey[],int bufix[],
int size){・・・｝」
/************************************************************************/
/***** ＳＯＲＴ： キー＝倍精度実数、添字＝３２ビット *****/
/************************************************************************/
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
double bufkey[], // キー部のバッファー
int bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){
int *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_double_0_key_ext( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_double_1_key_ext( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
} //☆備考☆この関数はファイル「CopyClear120」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortIndex()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
「Index」は、英語「index」≒索引、カタカナ語でも
インデックス、ココでは、ソート対象のキー配列に連動して
順番が、インデックスも入れ替わる事で別の関連するデータ
構造を並び替える為の補助に使用するための関数です！
（Ｂ）関数「int SortIndex()」の【返値】
正常終了≪ソートサイズが０以下の場合、詰り、処理出来無
かった場合も含む≫は、辺値「END_STI」を返し、内部で
エラーが発生した場合を記載シヨウとしたが実際にはメモリ
確保を行う方法から変更したので常に辺値「END_STI」を返
し正常終了します！
正常終了≪ソートサイズが０以下の場合、詰り、処理出来無
かった場合も含む≫は、辺値「END_STI」を返し、内部で
メモリ確保を行う事に失敗した場合は、エラーコード「
STI_MEM」を返します！
（Ｃ）関数「SortIndex()」の【仮引数】
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
double bufkey[], // キー部のバッファー
int bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「double bufkey[],」は、ソート対象のキー配列です！
今回は「double型」と８バイト倍精度浮動小数型！
「int bufix[], 」は、キー配列に連動して並び替えラレル
インデックス配列です！★注意★この関数の実行で初めて
インデックス値が、セット去れます！予めデータをセットし
ても新規に内部でセットした値に置き換わります！
★備考★「（４－１４－７４）」から、「int bufix[],」
と「（４－１４－７３）」までの「short bufix[], 」と
インデックス配列が「short型」から「int型」に変更した
関数です！☆注意☆これは、サイズが「short型」の場合、
３２７６７個まで使用可能で「int型」に変更で
２１４７４８３６４７個まで理論上可能≒実質的に無制限！
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「SortIndex()」の【アルゴリズム】
){
int *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_double_0_key_ext( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_double_1_key_ext( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
} //（Ｄ－１）ローカル変数
){
int *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt「int* ptr_ix;」は、インデックス配列への操作ポインタ
「int i;」は、ループカウンタ及び添字（インデックス）
の値！
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_double_0_key_ext( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_double_1_key_ext( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
} //「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「ptr_ix=bufix;」は、インデックス配列への操作ポインタ
セット！
「for(i=0;i<size;i++){*ptr_ix++=i;}」は、ループカウン
タ「i」が「0」から「size-1」まで繰り返し、インデック
ス配列へループカウンタの値をセット！
「if(sw==0){sort_double_0_key_ext(bufkey,&bufkey[size-1],
bufix,&bufix[size-1]);}」は、条件「sw==0」詰り、
昇順ソート時成立でサブルーチン関数
「sort_double_0_key_ext(bufkey,&bufkey[size-1],bufix,
&bufix[size-1]);」でキー配列「bufkey」をソート！
「else{sort_double_1_key_ext(bufkey,&bufkey[size-1],
bufix,&bufix[size-1]);}」は、不成立＝降順ソート時
成立でサブルーチン関数「sort_double_1_key_ext(bufkey,
&bufkey[size-1],bufix,&bufix[size-1]);」で
キー配列「bufkey」をソート！
「return(END_STI);」は、辺値「END_STI」を返し正常終了！
（４－１４－８０）関数「int SortIndex(int sw,
__int64 bufkey[],int bufix[],
int size){・・・｝」
/************************************************************************/
/***** ＳＯＲＴ： キー＝64Bit整数、添字＝３２ビット *****/
/************************************************************************/
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
__int64 bufkey[], // キー部のバッファー
int bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){
int *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_int64_0_key_ext( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_int64_1_key_ext( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
} //☆備考☆この関数はファイル「CopyClear120」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortIndex()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えで、今回は、昇順≪小さい方
から大きい方へ≫、降順≪大きい方から小さい方へ≫です！
「Index」は、英語「index」≒索引、カタカナ語でも
インデックス、ココでは、ソート対象のキー配列に連動して
順番が、インデックスも入れ替わる事で別の関連するデータ
構造を並び替える為の補助に使用するための関数です！
（Ｂ）関数「int SortIndex()」の【返値】
正常終了≪ソートサイズが０以下の場合、詰り、処理出来無
かった場合も含む≫は、辺値「END_STI」を返し、内部で
エラーが発生した場合を記載シヨウとしたが実際にはメモリ
確保を行う方法から変更したので常に辺値「END_STI」を返
し正常終了します！
（Ｃ）関数「SortIndex()」の【仮引数】
int CopyClear::SortIndex(
int sw, // 0:Key昇順、 1:Key降順
__int64 bufkey[], // キー部のバッファー
int bufix[], // 添字部のバッファー
int size // バッファーのサイズ
){「int sw,」は、「0:昇順、1:降順」と昇順／降順切り替え
「__int64 bufkey[],」は、ソート対象のキー配列です！
今回は「__int64型」と８バイト整数型！
「int bufix[], 」は、キー配列に連動して並び替えラレル
インデックス配列です！★注意★この関数の実行で初めて
インデックス値が、セット去れます！予めデータをセットし
ても新規に内部でセットした値に置き換わります！
★備考★「（４－１４－７４）」から、「int bufix[],」
と「（４－１４－７３）」までの「short bufix[], 」と
インデックス配列が「short型」から「int型」に変更した
関数です！☆注意☆これは、サイズが「short型」の場合、
３２７６７個まで使用可能で「int型」に変更で
２１４７４８３６４７個まで理論上可能≒実質的に無制限！
「int size」は、ソート対象一次元配列のデータ数！
（Ｄ）関数「SortIndex()」の【アルゴリズム】
){
int *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_int64_0_key_ext( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_int64_1_key_ext( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
} //（Ｄ－１）ローカル変数
){
int *ptr_ix; // 添字部用Ptr
int i; // 添字部用初期値Cunt「int* ptr_ix;」は、インデックス配列への操作ポインタ
「int i;」は、ループカウンタ及び添字（インデックス）
の値！
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下なら
return( END_STI ); // 正常終了
} //
ptr_ix = bufix; // 添字部PtrをSetし
for( i = 0; i < size; i++ ){ // ０～サイズ－１まで
*ptr_ix++ = i; // 初期値を設定する
} //
if( sw == 0 ){ // 昇順キーソートなら
sort_int64_0_key_ext( // 昇順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
}else{ // 降順キーソートなら
sort_int64_1_key_ext( // 降順キーソートを行う
bufkey, &bufkey[ size - 1 ], //
bufix, &bufix[ size - 1 ] ); //
} //
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「ptr_ix=bufix;」は、インデックス配列への操作ポインタ
セット！
「for(i=0;i<size;i++){*ptr_ix++=i;}」は、ループカウン
タ「i」が「0」から「size-1」まで繰り返し、インデック
ス配列へループカウンタの値をセット！
「if(sw==0){sort_int64_0_key_ext(bufkey,&bufkey[size-1],
bufix,&bufix[size-1]);}」は、条件「sw==0」詰り、
昇順ソート時成立でサブルーチン関数
「sort_int64_0_key_ext(bufkey,&bufkey[size-1],bufix,
&bufix[size-1]);」でキー配列「bufkey」をソート！
「else{sort_int64_1_key_ext(bufkey,&bufkey[size-1],
bufix,&bufix[size-1]);}」は、不成立＝降順ソート時
成立でサブルーチン関数「sort_int64_1_key_ext(bufkey,
&bufkey[size-1],bufix,&bufix[size-1]);」で
キー配列「bufkey」をソート！
「return(END_STI);」は、辺値「END_STI」を返し正常終了！
（４－１４－８１）関数「int SortCopy(TypeArray* pa,
int n,short bufix[],int offset,int l){・・・｝」
/************************************************************************/
/***** データのソート（整列）コマンド用：添字Dataに従った並び替え *****/
/************************************************************************/
int CopyClear::SortCopy(
TypeArray *pa, // 配列1～10の情報
int n, // 配列の個数 0..99
short bufix[], // 添字部のBuffer
int offset, // 先頭からのOffset
int l // 配列の最小大きさ
){
int a; // 配列のAdr
int w; // 配列の処理単位
int sti; // ステータス情報
for( ; --n >= 0; pa++ ){ // 配列の個数分
a = pa->adr; // Adrを取出し
w = pa->w; // 処理単位を取出し
if( w == 1 ){ // BYTEDataの場合
sti = SortCopy( (BYTE*)a + offset, bufix, l ); // 左記で並び替え
}else if( w == 2 ){ // 2BYTEDataの場合
sti = SortCopy( (short*)a + offset, bufix, l ); // 左記で並び替え
}else if( w == 4 || w == 101 ){ // 4BYTEDataの場合
sti = SortCopy( (int*)a + offset, bufix, l ); // 左記で並び替え
}else{ // 倍精度実数の場合
sti = SortCopy( (double*)a + offset, bufix, l ); // 左記で並び替え
} //
if( sti != END_STI ){ // 異常があれば
return( sti ); // ステータスを返す
} //
} //
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortCopy()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Copy」は、勿論、カタカナ語コピーとして、ここでは、
関数「SortIndex()」でキー配列に連動して並び替えられた
インデックス配列を使用してコピーする事で指定した配列を
並び替える関数です！
（Ｂ）関数「int SortCopy()」の【返値】
中でサブルーチン関数として同名のオーバーロード関数「
SortCopy()」を内部で「sti = SortCopy()」とステータス
情報を実行毎にセットしていますが、全て「END_STI」と
正常終了ならば、「END_STI」を辺値として返し、
一つでもエラーコードが「END_STI」以外なら、その値を
辺値として返します！
（Ｃ）関数「SortCopy()」の【仮引数】
int CopyClear::SortCopy(
TypeArray *pa, // 配列1～10の情報
int n, // 配列の個数 0..99
short bufix[], // 添字部のBuffer
int offset, // 先頭からのOffset
int l // 配列の最小大きさ
){「TypeArray* pa,」は、画像で無く一次元配列へのポイン
タとして扱います！
「int n」は、配列の個数です！★備考★「pa,」とポイ
ンタに成って居る配列が複数存在する事も可能です！
★注意★何故、この様な関数が存在するかと言うと、
複数の配列を処理する場合と、もう一つ
ＡＤＳ社画像処理装置に簡易コマンド言語「ＰＩＰＬ」で
使用する為に開発当時は、構造体「TypeArray」でコマンド
の型で使用出来る様に扱う仕掛けで必要なだけでＣ言語で
ライブラリ関数を使用する人には知らなくても良い話ですが
私としては、画像処理言語「ＰＩＰＬ」をリニューアル作成
する心算ですので残して置いたのです！
「short bufix[], 」は、関数「SortIndex()」で
キー配列に連動して並び替えられたインデックス配列です
のでこのインデックス配列で「TypeArray pa,」の各配列
を入れ替えます！
「int offset,」は、各配列先頭からのオフセット
「int l」は、各配列をインデックス配列に従って並び
替える数量（長さ）！
（Ｄ）関数「SortCopy()」の【アルゴリズム】
){
int a; // 配列のAdr
int w; // 配列の処理単位
int sti; // ステータス情報
for( ; --n >= 0; pa++ ){ // 配列の個数分
a = pa->adr; // Adrを取出し
w = pa->w; // 処理単位を取出し
if( w == 1 ){ // BYTEDataの場合
sti = SortCopy( (BYTE*)a + offset, bufix, l ); // 左記で並び替え
}else if( w == 2 ){ // 2BYTEDataの場合
sti = SortCopy( (short*)a + offset, bufix, l ); // 左記で並び替え
}else if( w == 4 || w == 101 ){ // 4BYTEDataの場合
sti = SortCopy( (int*)a + offset, bufix, l ); // 左記で並び替え
}else{ // 倍精度実数の場合
sti = SortCopy( (double*)a + offset, bufix, l ); // 左記で並び替え
} //
if( sti != END_STI ){ // 異常があれば
return( sti ); // ステータスを返す
} //
} //
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
int a; // 配列のAdr
int w; // 配列の処理単位
int sti; // ステータス情報「int a;」は、クラス「TypeArray」のポインタを整数型
とし格納したメンバー変数「int adr」を扱い易い様に一旦
コピーして使う変数です！
「int w;」は、同じく「TypeArray」のメンバー変数「
char w」を扱い易い様に一旦、コピーして使う変数です！
「int sti;」は、ステータス情報（エラーコード等で
解説『エラーコード等各種単純定義』で説明）の一時置き場
（Ｄ－２）アルゴリズムコード
for( ; --n >= 0; pa++ ){ // 配列の個数分
a = pa->adr; // Adrを取出し
w = pa->w; // 処理単位を取出し
if( w == 1 ){ // BYTEDataの場合
sti = SortCopy( (BYTE*)a + offset, bufix, l ); // 左記で並び替え
}else if( w == 2 ){ // 2BYTEDataの場合
sti = SortCopy( (short*)a + offset, bufix, l ); // 左記で並び替え
}else if( w == 4 || w == 101 ){ // 4BYTEDataの場合
sti = SortCopy( (int*)a + offset, bufix, l ); // 左記で並び替え
}else{ // 倍精度実数の場合
sti = SortCopy( (double*)a + offset, bufix, l ); // 左記で並び替え
} //
if( sti != END_STI ){ // 異常があれば
return( sti ); // ステータスを返す
} //
} //
return( END_STI ); // 正常終了
}「for(;--n>=0;pa++){・・ループ中身・・}」は、仮引数
「int n」＝配列個数と仮引数「TypeArray* pa,」で示す
配列の個数分ループ条件「--n>=0;」と「n」中身を繰り
返します★備考★この【ループ条件「--n>=0;」】の様な
【--nとnの値が破壊（変更）】される事が問題無い場合に
このライブラリでは、高速化の為に使われて居る事を何度も
解説して居ますが、ヒツコク高速化の為ですと記載します！
このｆｏｒループ構文「pa++」で仮引数「
TypeArray* pa,」のポインタ「pa」をループ中身が終わる
度に一つ次のポインタ≪詰り、次の配列へ進める≫を行いま
す！そしてループ中身「a=pa->adr;w=pa->w;」で配列の
始点とバイト単位≪１・２・４と整数バイト数と単精度・
倍精度浮動小数点数型を示すタグ≫を取り出し、
「if(w==1){sti=SortCopy((BYTE*)a+offset,bufix,l);}」で
条件「w==1」≪詰り、１バイト整数型の場合≫の処理と
して「sti=SortCopy((BYTE*)a+offset,bufix,l);」で処理し、
辺値を一時的な変数「sti」に置く
「else if(w==2){sti=SortCopy((short*)a+offset,bufix,l);}」で
条件「w==2」≪詰り、２バイト整数型の場合≫の処理し、
辺値を一時的な変数「sti」に置く
「else if(w==4||w==101){sti=SortCopy((short*)a+offset,bufix,l);}」で
条件「w==4||w==101」≪詰り、４バイト整数型の場合及び
単精度浮動小数型≫の処理と処理し、辺値を一時的な
変数「sti」に置く、
「else{sti=SortCopy((double*)a+offset,bufix,l);}」で
「else」と明示的な条件以外≪詰り、倍精度浮動小数型
★備考★「TypeArray」を正規変数で中の情報を作成して
いたら、倍精度浮動小数型に成る筈で正規の関数以外で作成
した「TypeArray」では動作は保証出来ません≫の処理と
処理し、辺値を一時的な変数「sti」に置く、ループ中身の
最後に「if(sti!=END_STI){return(sti);}」として、
一時的な変数「sti」のステータス情報（エラーコード）が
正常終了以外ならば、エラー発生とし、エラーコードとして
辺値を変数「sti」の値をコノ関数の辺値とし返し関数終了！
「return(END_STI);」は、正常終了を辺値で返し関数終了！
（４－１４－８２）関数「int SortCopy(BYTE buf[],
short bufix[],int size){・・・｝」
/************************************************************************/
/***** ソートした添字に従い並び替える関数：バイト単位 *****/
/************************************************************************/
int CopyClear::SortCopy(
BYTE buf[], // 並び替え対象
short bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){
BYTE *temp; // １時的保管場所
BYTE *ptemp; // 上記のポインタ
BYTE *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (BYTE*)malloc( // Bufferを確保
sizeof(BYTE) * ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movb( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortCopy()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Copy」は、勿論、カタカナ語コピーとして、ここでは、
関数「SortIndex()」でキー配列に連動して並び替えられた
インデックス配列を使用してコピーする事で指定した配列を
並び替える関数です！
（Ｂ）関数「int Sort()」の【返値】
中で作業用のバッファ領域を動的に確保します！その確保が
成功したら、処理し、最後に正常終了として「END_STI」を
辺値として返し、メモリ確保に失敗したら
エラーコードとして「STI_MEM」を辺値として返します！
（Ｃ）関数「SortCopy()」の【仮引数】
int CopyClear::SortCopy(
BYTE buf[], // 並び替え対象
short bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){「BYTE buf[],」は、インデックス配列に依って並び替える
配列！
「short bufix[],」は、関数「SortIndex()」でキー配列に
連動して並び替えられたインデックス配列★備考★ここでは
「short型」なので３２７６７個以内のインデックス配列で
す！
「int size」は、並び変える配列の数
（Ｄ）関数「SortCopy()」の【アルゴリズム】
){
BYTE *temp; // １時的保管場所
BYTE *ptemp; // 上記のポインタ
BYTE *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (BYTE*)malloc( // Bufferを確保
sizeof(BYTE) * ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movb( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
BYTE *temp; // １時的保管場所
BYTE *ptemp; // 上記のポインタ
BYTE *pend; // 上記の終点「BYTE* temp; 」は、一時的にデータ配列の保管用
「BYTE* ptemp;」は、上記への操作ポインタ
「BYTE* pend; 」は、操作ポインタ終点
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (BYTE*)malloc( // Bufferを確保
sizeof(BYTE) * ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movb( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「temp=(BYTE*)malloc(sizeof(BYTE)*(size+10));」は、
一時的データ配列の保管場所を動的に確保！
「if(temp==0){return(STI_MEM);}」は、メモリ確保失敗時
は、辺値「STI_MEM」を関数の値とし返し関数終了！
「ptemp=temp;pend=&temp[size];」は、確保した一時
バッファの操作用始終点をセット！
「while(ptemp<pend){*ptemp++=buf[*bufix++];}」は、
Ｗｈｉｌｅループ条件「ptemp<pend」で確保した一時
バッファの操作用始終点間を始点から終点まで繰り返し
「*ptemp++=buf[*bufix++];」とバッファへ元のデータ
配列を並び替えた物を格納します！
「up_movb(temp,buf,size);」は、並び替えた値の入って
居るバッファの内容を仮引数「BYTE buf[],」に格納する
事で並び替えを完了！
「free(temp);」は、一時的に確保したバッファを確保し
たシステムに返す！
「return(END_STI);」は、正常終了を辺値で返し関数終了！
（４－１４－８３）関数「int SortCopy(short buf[],
short bufix[],int size){・・・｝」
/************************************************************************/
/***** ソートした添字に従い並び替える関数：２バイト単位 *****/
/************************************************************************/
int CopyClear::SortCopy(
short buf[], // 並び替え対象
short bufix[], // 添字部Buffer
int size // Bufferのサイズ
){
short *temp; // １時的保管場所
short *ptemp; // 上記のポインタ
short *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (short*)malloc( // Bufferを確保
sizeof(short) * ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movs( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortCopy()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Copy」は、勿論、カタカナ語コピーとして、ここでは、
関数「SortIndex()」でキー配列に連動して並び替えられた
インデックス配列を使用してコピーする事で指定した配列を
並び替える関数です！
（Ｂ）関数「int Sort()」の【返値】
中で作業用のバッファ領域を動的に確保します！その確保が
成功したら、処理し、最後に正常終了として「END_STI」を
辺値として返し、メモリ確保に失敗したら
エラーコードとして「STI_MEM」を辺値として返します！
（Ｃ）関数「SortCopy()」の【仮引数】
int CopyClear::SortCopy(
short buf[], // 並び替え対象
short bufix[], // 添字部Buffer
int size // Bufferのサイズ
){「short buf[],」は、インデックス配列に依って並び替える
配列！
「short bufix[],」は、関数「SortIndex()」でキー配列に
連動して並び替えられたインデックス配列★備考★ここでは
「short型」なので３２７６７個以内のインデックス配列で
す！
「int size」は、並び変える配列の数
（Ｄ）関数「SortCopy()」の【アルゴリズム】
){
short *temp; // １時的保管場所
short *ptemp; // 上記のポインタ
short *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (short*)malloc( // Bufferを確保
sizeof(short) * ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movs( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
short *temp; // １時的保管場所
short *ptemp; // 上記のポインタ
short *pend; // 上記の終点「short* temp; 」は、一時的にデータ配列の保管用
「short* ptemp;」は、上記への操作ポインタ
「short* pend; 」は、操作ポインタ終点
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (short*)malloc( // Bufferを確保
sizeof(short) * ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movs( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「temp=(short*)malloc(sizeof(short)*(size+10));」は、
一時的データ配列の保管場所を動的に確保！
「if(temp==0){return(STI_MEM);}」は、メモリ確保失敗時
は、辺値「STI_MEM」を関数の値とし返し関数終了！
「ptemp=temp;pend=&temp[size];」は、確保した一時
バッファの操作用始終点をセット！
「while(ptemp<pend){*ptemp++=buf[*bufix++];}」は、
Ｗｈｉｌｅループ条件「ptemp<pend」で確保した一時
バッファの操作用始終点間を始点から終点まで繰り返し
「*ptemp++=buf[*bufix++];」とバッファへ元のデータ
配列を並び替えた物を格納します！
「up_movs(temp,buf,size);」は、並び替えた値の入って
居るバッファの内容を仮引数「short buf[],」に格納する
事で並び替えを完了！
「free(temp);」は、一時的に確保したバッファを確保し
たシステムに返す！
「return(END_STI);」は、正常終了を辺値で返し関数終了！
（４－１４－８４）関数「int SortCopy(int buf[],
short bufix[],int size){・・・｝」
/************************************************************************/
/***** ソートした添字に従い並び替える関数：４バイト単位 *****/
/************************************************************************/
int CopyClear::SortCopy(
int buf[], // 並び替え対象
short bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){
int *temp; // １時的保管場所
int *ptemp; // 上記のポインタ
int *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (int*)malloc( // Bufferを確保
sizeof(int) * ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movi( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortCopy()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Copy」は、勿論、カタカナ語コピーとして、ここでは、
関数「SortIndex()」でキー配列に連動して並び替えられた
インデックス配列を使用してコピーする事で指定した配列を
並び替える関数です！
（Ｂ）関数「int Sort()」の【返値】
中で作業用のバッファ領域を動的に確保します！その確保が
成功したら、処理し、最後に正常終了として「END_STI」を
辺値として返し、メモリ確保に失敗したら
エラーコードとして「STI_MEM」を辺値として返します！
（Ｃ）関数「SortCopy()」の【仮引数】
int CopyClear::SortCopy(
int buf[], // 並び替え対象
short bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){「int buf[],」は、インデックス配列に依って並び替える
配列！
「short bufix[],」は、関数「SortIndex()」でキー配列に
連動して並び替えられたインデックス配列★備考★ここでは
「short型」なので３２７６７個以内のインデックス配列で
す！
「int size」は、並び変える配列の数
（Ｄ）関数「SortCopy()」の【アルゴリズム】
){
int *temp; // １時的保管場所
int *ptemp; // 上記のポインタ
int *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (int*)malloc( // Bufferを確保
sizeof(int) * ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movi( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
int *temp; // １時的保管場所
int *ptemp; // 上記のポインタ
int *pend; // 上記の終点「int* temp; 」は、一時的にデータ配列の保管用
「int* ptemp;」は、上記への操作ポインタ
「int* pend; 」は、操作ポインタ終点
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (int*)malloc( // Bufferを確保
sizeof(int) * ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movi( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「temp=(int*)malloc(sizeof(int)*(size+10));」は、
一時的データ配列の保管場所を動的に確保！
「if(temp==0){return(STI_MEM);}」は、メモリ確保失敗時
は、辺値「STI_MEM」を関数の値とし返し関数終了！
「ptemp=temp;pend=&temp[size];」は、確保した一時
バッファの操作用始終点をセット！
「while(ptemp<pend){*ptemp++=buf[*bufix++];}」は、
Ｗｈｉｌｅループ条件「ptemp<pend」で確保した一時
バッファの操作用始終点間を始点から終点まで繰り返し
「*ptemp++=buf[*bufix++];」とバッファへ元のデータ
配列を並び替えた物を格納します！
「up_movi(temp,buf,size);」は、並び替えた値の入って
居るバッファの内容を仮引数「int buf[],」に格納する
事で並び替えを完了！
「free(temp);」は、一時的に確保したバッファを確保し
たシステムに返す！
「return(END_STI);」は、正常終了を辺値で返し関数終了！
（４－１４－８５）関数「int SortCopy(float buf[],
short bufix[],int size){・・・｝」
/************************************************************************/
/***** ソートした添字に従い並び替える関数：４バイト単位：単精度*****/
/************************************************************************/
int CopyClear::SortCopy(
float buf[], // 並び替え対象
short bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){
return( SortCopy( (int*)buf, bufix, size ) ); // ４バイト単位で処理
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortCopy()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Copy」は、勿論、カタカナ語コピーとして、ここでは、
関数「SortIndex()」でキー配列に連動して並び替えられた
インデックス配列を使用してコピーする事で指定した配列を
並び替える関数です！
（Ｂ）関数「int Sort()」の【返値】
中で作業用のバッファ領域を動的に確保します！その確保が
成功したら、処理し、最後に正常終了として「END_STI」を
辺値として返し、メモリ確保に失敗したら
エラーコードとして「STI_MEM」を辺値として返します！
（Ｃ）関数「SortCopy()」の【仮引数】
int CopyClear::SortCopy(
float buf[], // 並び替え対象
short bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){「float buf[],」は、インデックス配列に依って並び替える
配列！
「short bufix[],」は、関数「SortIndex()」でキー配列に
連動して並び替えられたインデックス配列★備考★ここでは
「short型」なので３２７６７個以内のインデックス配列で
す！
「int size」は、並び変える配列の数
（Ｄ）関数「SortCopy()」の【アルゴリズム】
){
return( SortCopy( (int*)buf, bufix, size ) ); // ４バイト単位で処理
}「return(SortCopy((int*)buf,bufix,size));」は、型変換
し、「int*型」の「SortCopy()」で実行します★備考★
仮引数「float buf[],」と単精度浮動小数型ですから、
変に思うかもしれませんが、４バイト単位のデータ配列を
インデックス配列のインデックスで並び変えるので整数型も
実数型も関係有りません！
（４－１４－８６）関数「int SortCopy(double buf[],
short bufix[],int size){・・・｝」
/************************************************************************/
/***** ソートした添字に従い並び替える関数：倍精度単位 *****/
/************************************************************************/
int CopyClear::SortCopy(
double buf[], // 並び替え対象
short bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){
double *temp; // １時的保管場所
double *ptemp; // 上記のポインタ
double *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (double*)malloc( sizeof(double) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movd( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortCopy()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Copy」は、勿論、カタカナ語コピーとして、ここでは、
関数「SortIndex()」でキー配列に連動して並び替えられた
インデックス配列を使用してコピーする事で指定した配列を
並び替える関数です！
（Ｂ）関数「int Sort()」の【返値】
中で作業用のバッファ領域を動的に確保します！その確保が
成功したら、処理し、最後に正常終了として「END_STI」を
辺値として返し、メモリ確保に失敗したら
エラーコードとして「STI_MEM」を辺値として返します！
（Ｃ）関数「SortCopy()」の【仮引数】
int CopyClear::SortCopy(
double buf[], // 並び替え対象
short bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){「double buf[],」は、インデックス配列に依って並び替える
配列！
「short bufix[],」は、関数「SortIndex()」でキー配列に
連動して並び替えられたインデックス配列★備考★ここでは
「short型」なので３２７６７個以内のインデックス配列で
す！
「int size」は、並び変える配列の数
（Ｄ）関数「SortCopy()」の【アルゴリズム】
){
double *temp; // １時的保管場所
double *ptemp; // 上記のポインタ
double *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (double*)malloc( sizeof(double) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movd( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
double *temp; // １時的保管場所
double *ptemp; // 上記のポインタ
double *pend; // 上記の終点「double* temp; 」は、一時的にデータ配列の保管用
「double* ptemp;」は、上記への操作ポインタ
「double* pend; 」は、操作ポインタ終点
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (double*)malloc( sizeof(double) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movd( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「temp=(double*)malloc(sizeof(double)*(size+10));」は、
一時的データ配列の保管場所を動的に確保！
「if(temp==0){return(STI_MEM);}」は、メモリ確保失敗時
は、辺値「STI_MEM」を関数の値とし返し関数終了！
「ptemp=temp;pend=&temp[size];」は、確保した一時
バッファの操作用始終点をセット！
「while(ptemp<pend){*ptemp++=buf[*bufix++];}」は、
Ｗｈｉｌｅループ条件「ptemp<pend」で確保した一時
バッファの操作用始終点間を始点から終点まで繰り返し
「*ptemp++=buf[*bufix++];」とバッファへ元のデータ
配列を並び替えた物を格納します！
「up_movd(temp,buf,size);」は、並び替えた値の入って
居るバッファの内容を仮引数「double buf[],」に格納する
事で並び替えを完了！
「free(temp);」は、一時的に確保したバッファを確保し
たシステムに返す！
「return(END_STI);」は、正常終了を辺値で返し関数終了！
（４－１４－８７）関数「int SortCopy(__int64 buf[],
short bufix[],int size){・・・｝」
/************************************************************************/
/***** ソートした添字に従い並び替える関数：64Bit整数単位 *****/
/************************************************************************/
int CopyClear::SortCopy(
__int64 buf[], // 並び替え対象
short bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){
__int64 *temp; // １時的保管場所
__int64 *ptemp; // 上記のポインタ
__int64 *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (__int64*)malloc( sizeof(__int64) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortCopy()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Copy」は、勿論、カタカナ語コピーとして、ここでは、
関数「SortIndex()」でキー配列に連動して並び替えられた
インデックス配列を使用してコピーする事で指定した配列を
並び替える関数です！
（Ｂ）関数「int Sort()」の【返値】
中で作業用のバッファ領域を動的に確保します！その確保が
成功したら、処理し、最後に正常終了として「END_STI」を
辺値として返し、メモリ確保に失敗したら
エラーコードとして「STI_MEM」を辺値として返します！
（Ｃ）関数「SortCopy()」の【仮引数】
int CopyClear::SortCopy(
__int64 buf[], // 並び替え対象
short bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){「__int64 buf[],」は、インデックス配列に依って並び替える
配列！
「short bufix[],」は、関数「SortIndex()」でキー配列に
連動して並び替えられたインデックス配列★備考★ここでは
「short型」なので３２７６７個以内のインデックス配列で
す！
「int size」は、並び変える配列の数
（Ｄ）関数「SortCopy()」の【アルゴリズム】
){
__int64 *temp; // １時的保管場所
__int64 *ptemp; // 上記のポインタ
__int64 *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (__int64*)malloc( sizeof(__int64) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
__int64 *temp; // １時的保管場所
__int64 *ptemp; // 上記のポインタ
__int64 *pend; // 上記の終点「__int64* temp; 」は、一時的にデータ配列の保管用
「__int64* ptemp;」は、上記への操作ポインタ
「__int64* pend; 」は、操作ポインタ終点
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (__int64*)malloc( sizeof(__int64) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「temp=(__int64*)malloc(sizeof(__int64)*(size+10));」は、
一時的データ配列の保管場所を動的に確保！
「if(temp==0){return(STI_MEM);}」は、メモリ確保失敗時
は、辺値「STI_MEM」を関数の値とし返し関数終了！
「ptemp=temp;pend=&temp[size];」は、確保した一時
バッファの操作用始終点をセット！
「while(ptemp<pend){*ptemp++=buf[*bufix++];}」は、
Ｗｈｉｌｅループ条件「ptemp<pend」で確保した一時
バッファの操作用始終点間を始点から終点まで繰り返し
「*ptemp++=buf[*bufix++];」とバッファへ元のデータ
配列を並び替えた物を格納します！
「up_movv(temp,buf,size);」は、並び替えた値の入って
居るバッファの内容を仮引数「__int64 buf[],」に格納する
事で並び替えを完了！
「free(temp);」は、一時的に確保したバッファを確保し
たシステムに返す！
「return(END_STI);」は、正常終了を辺値で返し関数終了！
（Ｅ）関数「SortCopy()」の【備考】
字面だけの判断≪筆者が、ド貧乏に成った為、検証させる
コンパイラ＆実行環境が用意出来無いので解説『
投げ銭方式ライブラリのダウンロード』に記載した様に
コンパイラ＆実行環境が整うまで実際の検証は無理≫ですが
明らかにミス≪バグ≫を見つけてシマッタ？！
「up_movv(temp,buf,size);」は、正しくは、
「up_movv(temp,buf,size*sizeof(__int64));」と記載し
無ければ、データを内部バッファから結果を完全にコピー
出来無い筈です！
（４－１４－８８）関数「int SortCopy(void* buf[],
short bufix[],int size){・・・｝」
/************************************************************************/
/***** ソートした添字に従い並び替える関数：void* *****/
/************************************************************************/
int CopyClear::SortCopy(
void* buf[], // 並び替え対象
short bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){
void** temp; // １時的保管場所
void** ptemp; // 上記のポインタ
void** pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (void**)malloc( sizeof(void*) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, sizeof(void*) * size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortCopy()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Copy」は、勿論、カタカナ語コピーとして、ここでは、
関数「SortIndex()」でキー配列に連動して並び替えられた
インデックス配列を使用してコピーする事で指定した配列を
並び替える関数です！
（Ｂ）関数「int Sort()」の【返値】
中で作業用のバッファ領域を動的に確保します！その確保が
成功したら、処理し、最後に正常終了として「END_STI」を
辺値として返し、メモリ確保に失敗したら
エラーコードとして「STI_MEM」を辺値として返します！
（Ｃ）関数「SortCopy()」の【仮引数】
int CopyClear::SortCopy(
void* buf[], // 並び替え対象
short bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){「void* buf[],」は、インデックス配列に依って並び替える
配列！
「short bufix[],」は、関数「SortIndex()」でキー配列に
連動して並び替えられたインデックス配列★備考★ここでは
「short型」なので３２７６７個以内のインデックス配列で
す！
「int size」は、並び変える配列の数
（Ｄ）関数「SortCopy()」の【アルゴリズム】
){
void** temp; // １時的保管場所
void** ptemp; // 上記のポインタ
void** pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (void**)malloc( sizeof(void*) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, sizeof(void*) * size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
void** temp; // １時的保管場所
void** ptemp; // 上記のポインタ
void** pend; // 上記の終点「void** temp; 」は、一時的にデータ配列の保管用
「void** ptemp;」は、上記への操作ポインタ
「void** pend; 」は、操作ポインタ終点
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (void**)malloc( sizeof(void*) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, sizeof(void*) * size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「temp=(void**)malloc(sizeof(void*)*(size+10));」は、
一時的データ配列の保管場所を動的に確保！
「if(temp==0){return(STI_MEM);}」は、メモリ確保失敗時
は、辺値「STI_MEM」を関数の値とし返し関数終了！
「ptemp=temp;pend=&temp[size];」は、確保した一時
バッファの操作用始終点をセット！
「while(ptemp<pend){*ptemp++=buf[*bufix++];}」は、
Ｗｈｉｌｅループ条件「ptemp<pend」で確保した一時
バッファの操作用始終点間を始点から終点まで繰り返し
「*ptemp++=buf[bufix++];」とバッファへ元のデータ
配列を並び替えた物を格納します！
「up_movv(temp,buf,sizeof(void)size);」は、並び替え
た値の入って居るバッファの内容を仮引数「void buf[],」
に格納する事で並び替えを完了！
「free(temp);」は、一時的に確保したバッファを確保し
たシステムに返す！
「return(END_STI);」は、正常終了を辺値で返し関数終了！
（４－１４－８９）関数「int SortCopy(TypeXY buf[],
short bufix[],int size){・・・｝」
/************************************************************************/
/***** ソートした添字に従い並び替える関数：TypeXY *****/
/************************************************************************/
int CopyClear::SortCopy(
TypeXY buf[], // 並び替え対象
short bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){
TypeXY *temp; // １時的保管場所
TypeXY *ptemp; // 上記のポインタ
TypeXY *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (TypeXY*)malloc( sizeof(TypeXY) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, sizeof(TypeXY) * size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortCopy()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Copy」は、勿論、カタカナ語コピーとして、ここでは、
関数「SortIndex()」でキー配列に連動して並び替えられた
インデックス配列を使用してコピーする事で指定した配列を
並び替える関数です！
（Ｂ）関数「int Sort()」の【返値】
中で作業用のバッファ領域を動的に確保します！その確保が
成功したら、処理し、最後に正常終了として「END_STI」を
辺値として返し、メモリ確保に失敗したら
エラーコードとして「STI_MEM」を辺値として返します！
（Ｃ）関数「SortCopy()」の【仮引数】
int CopyClear::SortCopy(
TypeXY buf[], // 並び替え対象
short bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){「TypeXY buf[],」は、インデックス配列に依って並び替える
配列！
「short bufix[],」は、関数「SortIndex()」でキー配列に
連動して並び替えられたインデックス配列★備考★ここでは
「short型」なので３２７６７個以内のインデックス配列で
す！
「int size」は、並び変える配列の数
（Ｄ）関数「SortCopy()」の【アルゴリズム】
){
TypeXY *temp; // １時的保管場所
TypeXY *ptemp; // 上記のポインタ
TypeXY *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (TypeXY*)malloc( sizeof(TypeXY) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, sizeof(TypeXY) * size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
TypeXY *temp; // １時的保管場所
TypeXY *ptemp; // 上記のポインタ
TypeXY *pend; // 上記の終点「TypeXY* temp; 」は、一時的にデータ配列の保管用
「TypeXY* ptemp;」は、上記への操作ポインタ
「TypeXY* pend; 」は、操作ポインタ終点
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (TypeXY*)malloc( sizeof(TypeXY) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, sizeof(TypeXY) * size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「temp=(TypeXY*)malloc(sizeof(TypeXY)*(size+10));」は、
一時的データ配列の保管場所を動的に確保！
「if(temp==0){return(STI_MEM);}」は、メモリ確保失敗時
は、辺値「STI_MEM」を関数の値とし返し関数終了！
「ptemp=temp;pend=&temp[size];」は、確保した一時
バッファの操作用始終点をセット！
「while(ptemp<pend){*ptemp++=buf[*bufix++];}」は、
Ｗｈｉｌｅループ条件「ptemp<pend」で確保した一時
バッファの操作用始終点間を始点から終点まで繰り返し
「*ptemp++=buf[*bufix++];」とバッファへ元のデータ
配列を並び替えた物を格納します！
「up_movv(temp,buf,sizeof(TypeXY)*size);」は、並び
替えた値の入って居るバッファの内容を仮引数「
TypeXY buf[],」に格納する事で並び替えを完了！
「free(temp);」は、一時的に確保したバッファを確保し
たシステムに返す！
「return(END_STI);」は、正常終了を辺値で返し関数終了！
（４－１４－９０）関数「int SortCopy(TypeXYI buf[],
short bufix[],int size){・・・｝」
/************************************************************************/
/***** ソートした添字に従い並び替える関数：TypeXYI *****/
/************************************************************************/
int CopyClear::SortCopy(
TypeXYI buf[], // 並び替え対象
short bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){
TypeXYI *temp; // １時的保管場所
TypeXYI *ptemp; // 上記のポインタ
TypeXYI *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (TypeXYI*)malloc( sizeof(TypeXYI) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, sizeof(TypeXYI) * size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortCopy()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Copy」は、勿論、カタカナ語コピーとして、ここでは、
関数「SortIndex()」でキー配列に連動して並び替えられた
インデックス配列を使用してコピーする事で指定した配列を
並び替える関数です！
（Ｂ）関数「int Sort()」の【返値】
中で作業用のバッファ領域を動的に確保します！その確保が
成功したら、処理し、最後に正常終了として「END_STI」を
辺値として返し、メモリ確保に失敗したら
エラーコードとして「STI_MEM」を辺値として返します！
（Ｃ）関数「SortCopy()」の【仮引数】
int CopyClear::SortCopy(
TypeXYI buf[], // 並び替え対象
short bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){「TypeXYI buf[],」は、インデックス配列に依って並び替える
配列！
「short bufix[],」は、関数「SortIndex()」でキー配列に
連動して並び替えられたインデックス配列★備考★ここでは
「short型」なので３２７６７個以内のインデックス配列で
す！
「int size」は、並び変える配列の数
（Ｄ）関数「SortCopy()」の【アルゴリズム】
){
TypeXYI *temp; // １時的保管場所
TypeXYI *ptemp; // 上記のポインタ
TypeXYI *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (TypeXYI*)malloc( sizeof(TypeXYI) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, sizeof(TypeXYI) * size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
TypeXYI *temp; // １時的保管場所
TypeXYI *ptemp; // 上記のポインタ
TypeXYI *pend; // 上記の終点「TypeXYI* temp; 」は、一時的にデータ配列の保管用
「TypeXYI* ptemp;」は、上記への操作ポインタ
「TypeXYI* pend; 」は、操作ポインタ終点
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (TypeXYI*)malloc( sizeof(TypeXYI) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, sizeof(TypeXYI) * size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「temp=(TypeXYI*)malloc(sizeof(TypeXYI)*(size+10));」は、
一時的データ配列の保管場所を動的に確保！
「if(temp==0){return(STI_MEM);}」は、メモリ確保失敗時
は、辺値「STI_MEM」を関数の値とし返し関数終了！
「ptemp=temp;pend=&temp[size];」は、確保した一時
バッファの操作用始終点をセット！
「while(ptemp<pend){*ptemp++=buf[*bufix++];}」は、
Ｗｈｉｌｅループ条件「ptemp<pend」で確保した一時
バッファの操作用始終点間を始点から終点まで繰り返し
「*ptemp++=buf[*bufix++];」とバッファへ元のデータ
配列を並び替えた物を格納します！
「up_movv(temp,buf,sizeof(TypeXYI)*size);」は、並び
替えた値の入って居るバッファの内容を仮引数「
TypeXYI buf[],」に格納する事で並び替えを完了！
「free(temp);」は、一時的に確保したバッファを確保し
たシステムに返す！
「return(END_STI);」は、正常終了を辺値で返し関数終了！
（４－１４－９１）関数「int SortCopy(TypeXYHV buf[],
short bufix[],int size){・・・｝」
/************************************************************************/
/***** ソートした添字に従い並び替える関数：TypeXYHV *****/
/************************************************************************/
int CopyClear::SortCopy(
TypeXYHV buf[], // 並び替え対象
short bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){
TypeXYHV *temp; // １時的保管場所
TypeXYHV *ptemp; // 上記のポインタ
TypeXYHV *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (TypeXYHV*)malloc( sizeof(TypeXYHV) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, sizeof(TypeXYHV) * size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear100」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortCopy()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Copy」は、勿論、カタカナ語コピーとして、ここでは、
関数「SortIndex()」でキー配列に連動して並び替えられた
インデックス配列を使用してコピーする事で指定した配列を
並び替える関数です！
（Ｂ）関数「int Sort()」の【返値】
中で作業用のバッファ領域を動的に確保します！その確保が
成功したら、処理し、最後に正常終了として「END_STI」を
辺値として返し、メモリ確保に失敗したら
エラーコードとして「STI_MEM」を辺値として返します！
（Ｃ）関数「SortCopy()」の【仮引数】
int CopyClear::SortCopy(
TypeXYHV buf[], // 並び替え対象
short bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){「TypeXYHV buf[],」は、インデックス配列に依って並び替える配列！
「short bufix[],」は、関数「SortIndex()」でキー配列に
連動して並び替えられたインデックス配列★備考★ここでは
「short型」なので３２７６７個以内のインデックス配列で
す！
「int size」は、並び変える配列の数
（Ｄ）関数「SortCopy()」の【アルゴリズム】
){
TypeXYHV *temp; // １時的保管場所
TypeXYHV *ptemp; // 上記のポインタ
TypeXYHV *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (TypeXYHV*)malloc( sizeof(TypeXYHV) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, sizeof(TypeXYHV) * size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
TypeXYHV *temp; // １時的保管場所
TypeXYHV *ptemp; // 上記のポインタ
TypeXYHV *pend; // 上記の終点「TypeXYHV* temp; 」は、一時的にデータ配列の保管用
「TypeXYHV* ptemp;」は、上記への操作ポインタ
「TypeXYHV* pend; 」は、操作ポインタ終点
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (TypeXYHV*)malloc( sizeof(TypeXYHV) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, sizeof(TypeXYHV) * size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「temp=(TypeXYHV*)malloc(sizeof(TypeXYHV)*(size+10));」は、
一時的データ配列の保管場所を動的に確保！
「if(temp==0){return(STI_MEM);}」は、メモリ確保失敗時
は、辺値「STI_MEM」を関数の値とし返し関数終了！
「ptemp=temp;pend=&temp[size];」は、確保した一時
バッファの操作用始終点をセット！
「while(ptemp<pend){*ptemp++=buf[*bufix++];}」は、
Ｗｈｉｌｅループ条件「ptemp<pend」で確保した一時
バッファの操作用始終点間を始点から終点まで繰り返し
「*ptemp++=buf[*bufix++];」とバッファへ元のデータ
配列を並び替えた物を格納します！
「up_movv(temp,buf,sizeof(TypeXYHV)*size);」は、並び
替えた値の入って居るバッファの内容を仮引数「
TypeXYHV buf[],」に格納する事で並び替えを完了！
「free(temp);」は、一時的に確保したバッファを確保し
たシステムに返す！
「return(END_STI);」は、正常終了を辺値で返し関数終了！
（４－１４－９２）関数「int SortCopy(TypeArray* pa,int n,
int bufix[],int offset,int l){・・・｝」
/************************************************************************/
/***** データのソート（整列）コマンド用：添字Dataに従った並び替え *****/
/***** ★添字＝３２ビット★*****/
/************************************************************************/
int CopyClear::SortCopy(
TypeArray *pa, // 配列1～10の情報
int n, // 配列の個数 0..99
int bufix[], // 添字部のBuffer
int offset, // 先頭からのOffset
int l // 配列の最小大きさ
){
int a; // 配列のAdr
int w; // 配列の処理単位
int sti; // ステータス情報
for( ; --n >= 0; pa++ ){ // 配列の個数分
a = pa->adr; // Adrを取出し
w = pa->w; // 処理単位を取出し
if( w == 1 ){ // BYTEDataの場合
sti = SortCopy( (BYTE*)a + offset, bufix, l ); // 左記で並び替え
}else if( w == 2 ){ // 2BYTEDataの場合
sti = SortCopy( (short*)a + offset, bufix, l ); // 左記で並び替え
}else if( w == 4 || w == 101 ){ // 4BYTEDataの場合
sti = SortCopy( (int*)a + offset, bufix, l ); // 左記で並び替え
}else{ // 倍精度実数の場合
sti = SortCopy( (double*)a + offset, bufix, l ); // 左記で並び替え
} //
if( sti != END_STI ){ // 異常があれば
return( sti ); // ステータスを返す
} //
} //
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear120」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortCopy()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Copy」は、勿論、カタカナ語コピーとして、ここでは、
関数「SortIndex()」でキー配列に連動して並び替えられた
インデックス配列を使用してコピーする事で指定した配列を
並び替える関数です！
（Ｂ）関数「int Sort()」の【返値】
中でサブルーチン関数として同名のオーバーロード関数「
SortCopy()」を内部で「sti = SortCopy()」とステータス
情報を実行毎にセットしていますが、全て「END_STI」と
正常終了ならば、「END_STI」を辺値として返し、
一つでもエラーコードが「END_STI」以外なら、その値を
辺値として返します！
（Ｃ）関数「SortCopy()」の【仮引数】
int CopyClear::SortCopy(
TypeArray *pa, // 配列1～10の情報
int n, // 配列の個数 0..99
int bufix[], // 添字部のBuffer
int offset, // 先頭からのOffset
int l // 配列の最小大きさ
){「TypeArray* pa,」は、画像で無く一次元配列へのポイン
タとして扱います！
「int n」は、配列の個数です！★備考★「pa,」とポイ
ンタに成って居る配列が複数存在する事も可能です！
★注意★何故、この様な関数が存在するかと言うと、
複数の配列を処理する場合と、もう一つ
ＡＤＳ社画像処理装置に簡易コマンド言語「ＰＩＰＬ」で
使用する為に開発当時は、構造体「TypeArray」でコマンド
の型で使用出来る様に扱う仕掛けで必要なだけでＣ言語で
ライブラリ関数を使用する人には知らなくても良い話ですが
私としては、画像処理言語「ＰＩＰＬ」をリニューアル作成
する心算ですので残して置いたのです！
「int bufix[], 」は、関数「SortIndex()」で
キー配列に連動して並び替えられたインデックス配列です
のでこのインデックス配列で「TypeArray pa,」の各配列
を入れ替えます！★備考★インデックス配列が「int型」に
成っているコノ関数は、「short型」の制約≪個数の上限が
３２７６７≫を越える場合の関数です！勿論、「int型」に
すると処理時間が余計に罹る事は理解して頂けると思います
が、「short型」の方が速度が早いので制約内使用では十分
と考えて先に作成し、コノ関数は遅い動作でも制約が無い
関数として後で作成しました！
「int offset,」は、各配列先頭からのオフセット
「int l」は、各配列をインデックス配列に従って並び
替える数量（長さ）！
（Ｄ）関数「SortCopy()」の【アルゴリズム】
){
int a; // 配列のAdr
int w; // 配列の処理単位
int sti; // ステータス情報
for( ; --n >= 0; pa++ ){ // 配列の個数分
a = pa->adr; // Adrを取出し
w = pa->w; // 処理単位を取出し
if( w == 1 ){ // BYTEDataの場合
sti = SortCopy( (BYTE*)a + offset, bufix, l ); // 左記で並び替え
}else if( w == 2 ){ // 2BYTEDataの場合
sti = SortCopy( (short*)a + offset, bufix, l ); // 左記で並び替え
}else if( w == 4 || w == 101 ){ // 4BYTEDataの場合
sti = SortCopy( (int*)a + offset, bufix, l ); // 左記で並び替え
}else{ // 倍精度実数の場合
sti = SortCopy( (double*)a + offset, bufix, l ); // 左記で並び替え
} //
if( sti != END_STI ){ // 異常があれば
return( sti ); // ステータスを返す
} //
} //
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
int a; // 配列のAdr
int w; // 配列の処理単位
int sti; // ステータス情報「int a;」は、クラス「TypeArray」のポインタを整数型
とし格納したメンバー変数「int adr」を扱い易い様に一旦
コピーして使う変数です！
「int w;」は、同じく「TypeArray」のメンバー変数「
char w」を扱い易い様に一旦、コピーして使う変数です！
「int sti;」は、ステータス情報（エラーコード等で
解説『エラーコード等各種単純定義』で説明）の一時置き場
（Ｄ－２）アルゴリズムコード
for( ; --n >= 0; pa++ ){ // 配列の個数分
a = pa->adr; // Adrを取出し
w = pa->w; // 処理単位を取出し
if( w == 1 ){ // BYTEDataの場合
sti = SortCopy( (BYTE*)a + offset, bufix, l ); // 左記で並び替え
}else if( w == 2 ){ // 2BYTEDataの場合
sti = SortCopy( (short*)a + offset, bufix, l ); // 左記で並び替え
}else if( w == 4 || w == 101 ){ // 4BYTEDataの場合
sti = SortCopy( (int*)a + offset, bufix, l ); // 左記で並び替え
}else{ // 倍精度実数の場合
sti = SortCopy( (double*)a + offset, bufix, l ); // 左記で並び替え
} //
if( sti != END_STI ){ // 異常があれば
return( sti ); // ステータスを返す
} //
} //
return( END_STI ); // 正常終了
}「for(;--n>=0;pa++){・・ループ中身・・}」は、仮引数
「int n」＝配列個数と仮引数「TypeArray* pa,」で示す
配列の個数分ループ条件「--n>=0;」と「n」中身を繰り
返します★備考★この【ループ条件「--n>=0;」】の様な
【--nとnの値が破壊（変更）】される事が問題無い場合に
このライブラリでは、高速化の為に使われて居る事を何度も
解説して居ますが、ヒツコク高速化の為ですと記載します！
このｆｏｒループ構文「pa++」で仮引数「
TypeArray* pa,」のポインタ「pa」をループ中身が終わる
度に一つ次のポインタ≪詰り、次の配列へ進める≫を行いま
す！そしてループ中身「a=pa->adr;w=pa->w;」で配列の
始点とバイト単位≪１・２・４と整数バイト数と単精度・
倍精度浮動小数点数型を示すタグ≫を取り出し、
「if(w==1){sti=SortCopy((BYTE*)a+offset,bufix,l);}」で
条件「w==1」≪詰り、１バイト整数型の場合≫の処理と
して「sti=SortCopy((BYTE*)a+offset,bufix,l);」で処理し、
辺値を一時的な変数「sti」に置く
「else if(w==2){sti=SortCopy((short*)a+offset,bufix,l);}」で
条件「w==2」≪詰り、２バイト整数型の場合≫の処理し、
辺値を一時的な変数「sti」に置く
「else if(w==4||w==101){sti=SortCopy((short*)a+offset,bufix,l);}」で
条件「w==4||w==101」≪詰り、４バイト整数型の場合及び
単精度浮動小数型≫の処理と処理し、辺値を一時的な
変数「sti」に置く、
「else{sti=SortCopy((double*)a+offset,bufix,l);}」で
「else」と明示的な条件以外≪詰り、倍精度浮動小数型
★備考★「TypeArray」を正規変数で中の情報を作成して
いたら、倍精度浮動小数型に成る筈で正規の関数以外で作成
した「TypeArray」では動作は保証出来ません≫の処理と
処理し、辺値を一時的な変数「sti」に置く、ループ中身の
最後に「if(sti!=END_STI){return(sti);}」として、
一時的な変数「sti」のステータス情報（エラーコード）が
正常終了以外ならば、エラー発生とし、エラーコードとして
辺値を変数「sti」の値をコノ関数の辺値とし返し関数終了！
「return(END_STI);」は、正常終了を辺値で返し関数終了！
（４－１４－９３）関数「int SortCopy(BYTE buf[],
int bufix[],int size){・・・｝」
for( ; --n >= 0; pa++ ){ // 配列の個数分
a = pa->adr; // Adrを取出し
w = pa->w; // 処理単位を取出し
if( w == 1 ){ // BYTEDataの場合
sti = SortCopy( (BYTE*)a + offset, bufix, l ); // 左記で並び替え
}else if( w == 2 ){ // 2BYTEDataの場合
sti = SortCopy( (short*)a + offset, bufix, l ); // 左記で並び替え
}else if( w == 4 || w == 101 ){ // 4BYTEDataの場合
sti = SortCopy( (int*)a + offset, bufix, l ); // 左記で並び替え
}else{ // 倍精度実数の場合
sti = SortCopy( (double*)a + offset, bufix, l ); // 左記で並び替え
} //
if( sti != END_STI ){ // 異常があれば
return( sti ); // ステータスを返す
} //
} //
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear120」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortCopy()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Copy」は、勿論、カタカナ語コピーとして、ここでは、
関数「SortIndex()」でキー配列に連動して並び替えられた
インデックス配列を使用してコピーする事で指定した配列を
並び替える関数です！
（Ｂ）関数「int Sort()」の【返値】
中で作業用のバッファ領域を動的に確保します！その確保が
成功したら、処理し、最後に正常終了として「END_STI」を
辺値として返し、メモリ確保に失敗したら
エラーコードとして「STI_MEM」を辺値として返します！
（Ｃ）関数「SortCopy()」の【仮引数】
int CopyClear::SortCopy(
BYTE buf[], // 並び替え対象
int bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){「BYTE buf[],」は、インデックス配列に依って並び替える
配列！
「int bufix[],」は、関数「SortIndex()」でキー配列に
連動して並び替えられたインデックス配列★備考★ここでは
「int型」なので制約個数無しのインデックス配列です！
「int size」は、並び変える配列の数
（Ｄ）関数「SortCopy()」の【アルゴリズム】
){
BYTE *temp; // １時的保管場所
BYTE *ptemp; // 上記のポインタ
BYTE *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (BYTE*)malloc( // Bufferを確保
sizeof(BYTE) * ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movb( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
BYTE *temp; // １時的保管場所
BYTE *ptemp; // 上記のポインタ
BYTE *pend; // 上記の終点「BYTE* temp; 」は、一時的にデータ配列の保管用
「BYTE* ptemp;」は、上記への操作ポインタ
「BYTE* pend; 」は、操作ポインタ終点
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (BYTE*)malloc( // Bufferを確保
sizeof(BYTE) * ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movb( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「temp=(BYTE*)malloc(sizeof(BYTE)*(size+10));」は、
一時的データ配列の保管場所を動的に確保！
「if(temp==0){return(STI_MEM);}」は、メモリ確保失敗時
は、辺値「STI_MEM」を関数の値とし返し関数終了！
「ptemp=temp;pend=&temp[size];」は、確保した一時
バッファの操作用始終点をセット！
「while(ptemp<pend){*ptemp++=buf[*bufix++];}」は、
Ｗｈｉｌｅループ条件「ptemp<pend」で確保した一時
バッファの操作用始終点間を始点から終点まで繰り返し
「*ptemp++=buf[*bufix++];」とバッファへ元のデータ
配列を並び替えた物を格納します！
「up_movb(temp,buf,size);」は、並び替えた値の入って
居るバッファの内容を仮引数「BYTE buf[],」に格納する
事で並び替えを完了！
「free(temp);」は、一時的に確保したバッファを確保し
たシステムに返す！
「return(END_STI);」は、正常終了を辺値で返し関数終了！
（４－１４－９４）関数「int SortCopy(short buf[],
int bufix[],int size){・・・｝」
/************************************************************************/
/***** ソートした添字に従い並び替える関数：２バイト単位 *****/
/************************************************************************/
int CopyClear::SortCopy(
short buf[], // 並び替え対象
int bufix[], // 添字部Buffer
int size // Bufferのサイズ
){
short *temp; // １時的保管場所
short *ptemp; // 上記のポインタ
short *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (short*)malloc( // Bufferを確保
sizeof(short) * ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movs( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear120」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortCopy()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Copy」は、勿論、カタカナ語コピーとして、ここでは、
関数「SortIndex()」でキー配列に連動して並び替えられた
インデックス配列を使用してコピーする事で指定した配列を
並び替える関数です！
（Ｂ）関数「int Sort()」の【返値】
中で作業用のバッファ領域を動的に確保します！その確保が
成功したら、処理し、最後に正常終了として「END_STI」を
辺値として返し、メモリ確保に失敗したら
エラーコードとして「STI_MEM」を辺値として返します！
（Ｃ）関数「SortCopy()」の【仮引数】
int CopyClear::SortCopy(
short buf[], // 並び替え対象
int bufix[], // 添字部Buffer
int size // Bufferのサイズ
){「short buf[],」は、インデックス配列に依って並び替える
配列！
「int bufix[],」は、関数「SortIndex()」でキー配列に
連動して並び替えられたインデックス配列★備考★ここでは
「int型」なので制約個数無しのインデックス配列です！
「int size」は、並び変える配列の数！
（Ｄ）関数「SortCopy()」の【アルゴリズム】
){
short *temp; // １時的保管場所
short *ptemp; // 上記のポインタ
short *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (short*)malloc( // Bufferを確保
sizeof(short) * ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movs( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
short *temp; // １時的保管場所
short *ptemp; // 上記のポインタ
short *pend; // 上記の終点「short* temp; 」は、一時的にデータ配列の保管用
「short* ptemp;」は、上記への操作ポインタ
「short* pend; 」は、操作ポインタ終点
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (short*)malloc( // Bufferを確保
sizeof(short) * ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movs( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「temp=(short*)malloc(sizeof(short)*(size+10));」は、
一時的データ配列の保管場所を動的に確保！
「if(temp==0){return(STI_MEM);}」は、メモリ確保失敗時
は、辺値「STI_MEM」を関数の値とし返し関数終了！
「ptemp=temp;pend=&temp[size];」は、確保した一時
バッファの操作用始終点をセット！
「while(ptemp<pend){*ptemp++=buf[*bufix++];}」は、
Ｗｈｉｌｅループ条件「ptemp<pend」で確保した一時
バッファの操作用始終点間を始点から終点まで繰り返し
「*ptemp++=buf[*bufix++];」とバッファへ元のデータ
配列を並び替えた物を格納します！
「up_movs(temp,buf,size);」は、並び替えた値の入って
居るバッファの内容を仮引数「short buf[],」に格納する
事で並び替えを完了！
「free(temp);」は、一時的に確保したバッファを確保し
たシステムに返す！
「return(END_STI);」は、正常終了を辺値で返し関数終了！
（４－１４－９５）関数「int SortCopy(int buf[],
int bufix[],int size){・・・｝」
/************************************************************************/
/***** ソートした添字に従い並び替える関数：４バイト単位 *****/
/************************************************************************/
int CopyClear::SortCopy(
int buf[], // 並び替え対象
int bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){
int *temp; // １時的保管場所
int *ptemp; // 上記のポインタ
int *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (int*)malloc( // Bufferを確保
sizeof(int) * ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movi( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear120」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortCopy()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Copy」は、勿論、カタカナ語コピーとして、ここでは、
関数「SortIndex()」でキー配列に連動して並び替えられた
インデックス配列を使用してコピーする事で指定した配列を
並び替える関数です！
（Ｂ）関数「int Sort()」の【返値】
中で作業用のバッファ領域を動的に確保します！その確保が
成功したら、処理し、最後に正常終了として「END_STI」を
辺値として返し、メモリ確保に失敗したら
エラーコードとして「STI_MEM」を辺値として返します！
（Ｃ）関数「SortCopy()」の【仮引数】
int CopyClear::SortCopy(
int buf[], // 並び替え対象
int bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){「int buf[],」は、インデックス配列に依って並び替える
配列！
「int bufix[],」は、関数「SortIndex()」でキー配列に
連動して並び替えられたインデックス配列★備考★ここでは
「int型」なので制約個数無しのインデックス配列です！
「int size」は、並び変える配列の数！
（Ｄ）関数「SortCopy()」の【アルゴリズム】
){
int *temp; // １時的保管場所
int *ptemp; // 上記のポインタ
int *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (int*)malloc( // Bufferを確保
sizeof(int) * ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movi( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
int *temp; // １時的保管場所
int *ptemp; // 上記のポインタ
int *pend; // 上記の終点「int* temp; 」は、一時的にデータ配列の保管用
「int* ptemp;」は、上記への操作ポインタ
「int* pend; 」は、操作ポインタ終点
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (int*)malloc( // Bufferを確保
sizeof(int) * ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movi( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「temp=(int*)malloc(sizeof(int)*(size+10));」は、
一時的データ配列の保管場所を動的に確保！
「if(temp==0){return(STI_MEM);}」は、メモリ確保失敗時
は、辺値「STI_MEM」を関数の値とし返し関数終了！
「ptemp=temp;pend=&temp[size];」は、確保した一時
バッファの操作用始終点をセット！
「while(ptemp<pend){*ptemp++=buf[*bufix++];}」は、
Ｗｈｉｌｅループ条件「ptemp<pend」で確保した一時
バッファの操作用始終点間を始点から終点まで繰り返し
「*ptemp++=buf[*bufix++];」とバッファへ元のデータ
配列を並び替えた物を格納します！
「up_movi(temp,buf,size);」は、並び替えた値の入って
居るバッファの内容を仮引数「int buf[],」に格納する
事で並び替えを完了！
「free(temp);」は、一時的に確保したバッファを確保し
たシステムに返す！
「return(END_STI);」は、正常終了を辺値で返し関数終了！
（４－１４－９６）関数「int SortCopy(float buf[],int bufix[],
int size){・・・｝」
/************************************************************************/
/***** ソートした添字に従い並び替える関数：４バイト単位：単精度*****/
/************************************************************************/
int CopyClear::SortCopy(
float buf[], // 並び替え対象
int bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){
return( SortCopy( (int*)buf, bufix, size ) ); // ４バイト単位で処理
}☆備考☆この関数はファイル「CopyClear120」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortCopy()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Copy」は、勿論、カタカナ語コピーとして、ここでは、
関数「SortIndex()」でキー配列に連動して並び替えられた
インデックス配列を使用してコピーする事で指定した配列を
並び替える関数です！
（Ｂ）関数「int Sort()」の【返値】
中で作業用のバッファ領域を動的に確保します！その確保が
成功したら、処理し、最後に正常終了として「END_STI」を
辺値として返し、メモリ確保に失敗したら
エラーコードとして「STI_MEM」を辺値として返します！
（Ｃ）関数「SortCopy()」の【仮引数】
int CopyClear::SortCopy(
float buf[], // 並び替え対象
int bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){「float buf[],」は、インデックス配列に依って並び替える
配列！
「int bufix[],」は、関数「SortIndex()」でキー配列に
連動して並び替えられたインデックス配列★備考★ここでは
「int型」なので制約個数無しのインデックス配列です！
「int size」は、並び変える配列の数！
（Ｄ）関数「SortCopy()」の【アルゴリズム】
){
return( SortCopy( (int*)buf, bufix, size ) ); // ４バイト単位で処理
}「return(SortCopy((int*)buf,bufix,size));」は、型変換
し、「int*型」の「SortCopy()」で実行します★備考★
仮引数「float buf[],」と単精度浮動小数型ですから、
変に思うかもしれませんが、４バイト単位のデータ配列を
インデックス配列のインデックスで並び変えるので整数型も
実数型も関係有りません！
（４－１４－９７）関数「int SortCopy(double buf[],
int bufix[],int size){・・・｝」
/************************************************************************/
/***** ソートした添字に従い並び替える関数：倍精度 *****/
/************************************************************************/
int CopyClear::SortCopy(
double buf[], // 並び替え対象
int bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){
double *temp; // １時的保管場所
double *ptemp; // 上記のポインタ
double *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (double*)malloc( sizeof(double) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movd( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear120」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortCopy()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Copy」は、勿論、カタカナ語コピーとして、ここでは、
関数「SortIndex()」でキー配列に連動して並び替えられた
インデックス配列を使用してコピーする事で指定した配列を
並び替える関数です！
（Ｂ）関数「int Sort()」の【返値】
中で作業用のバッファ領域を動的に確保します！その確保が
成功したら、処理し、最後に正常終了として「END_STI」を
辺値として返し、メモリ確保に失敗したら
エラーコードとして「STI_MEM」を辺値として返します！
（Ｃ）関数「SortCopy()」の【仮引数】
int CopyClear::SortCopy(
double buf[], // 並び替え対象
int bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){「double buf[],」は、インデックス配列に依って並び替える
配列！
「int bufix[],」は、関数「SortIndex()」でキー配列に
連動して並び替えられたインデックス配列★備考★ここでは
「int型」なので制約個数無しのインデックス配列です！
「int size」は、並び変える配列の数！
（Ｄ）関数「SortCopy()」の【アルゴリズム】
){
double *temp; // １時的保管場所
double *ptemp; // 上記のポインタ
double *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (double*)malloc( sizeof(double) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movd( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
double *temp; // １時的保管場所
double *ptemp; // 上記のポインタ
double *pend; // 上記の終点「double* temp; 」は、一時的にデータ配列の保管用
「double* ptemp;」は、上記への操作ポインタ
「double* pend; 」は、操作ポインタ終点
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (double*)malloc( sizeof(double) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movd( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「temp=(double*)malloc(sizeof(double)*(size+10));」は、
一時的データ配列の保管場所を動的に確保！
「if(temp==0){return(STI_MEM);}」は、メモリ確保失敗時
は、辺値「STI_MEM」を関数の値とし返し関数終了！
「ptemp=temp;pend=&temp[size];」は、確保した一時
バッファの操作用始終点をセット！
「while(ptemp<pend){*ptemp++=buf[*bufix++];}」は、
Ｗｈｉｌｅループ条件「ptemp<pend」で確保した一時
バッファの操作用始終点間を始点から終点まで繰り返し
「*ptemp++=buf[*bufix++];」とバッファへ元のデータ
配列を並び替えた物を格納します！
「up_movd(temp,buf,size);」は、並び替えた値の入って
居るバッファの内容を仮引数「double buf[],」に格納する
事で並び替えを完了！
「free(temp);」は、一時的に確保したバッファを確保し
たシステムに返す！
「return(END_STI);」は、正常終了を辺値で返し関数終了！
（４－１４－９８）関数「int SortCopy(__int64 buf[],
int bufix[],int size){・・・｝」
/************************************************************************/
/***** ソートした添字に従い並び替える関数：64Bit整数 *****/
/************************************************************************/
int CopyClear::SortCopy(
__int64 buf[], // 並び替え対象
int bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){
__int64 *temp; // １時的保管場所
__int64 *ptemp; // 上記のポインタ
__int64 *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (__int64*)malloc( sizeof(__int64) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear120」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortCopy()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Copy」は、勿論、カタカナ語コピーとして、ここでは、
関数「SortIndex()」でキー配列に連動して並び替えられた
インデックス配列を使用してコピーする事で指定した配列を
並び替える関数です！
（Ｂ）関数「int Sort()」の【返値】
中で作業用のバッファ領域を動的に確保します！その確保が
成功したら、処理し、最後に正常終了として「END_STI」を
辺値として返し、メモリ確保に失敗したら
エラーコードとして「STI_MEM」を辺値として返します！
（Ｃ）関数「SortCopy()」の【仮引数】
int CopyClear::SortCopy(
__int64 buf[], // 並び替え対象
int bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){「__int64 buf[],」は、インデックス配列に依って並び替える
配列！
「int bufix[],」は、関数「SortIndex()」でキー配列に
連動して並び替えられたインデックス配列★備考★ここでは
「int型」なので制約個数無しのインデックス配列です！
「int size」は、並び変える配列の数！
（Ｄ）関数「SortCopy()」の【アルゴリズム】
){
__int64 *temp; // １時的保管場所
__int64 *ptemp; // 上記のポインタ
__int64 *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (__int64*)malloc( sizeof(__int64) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
__int64 *temp; // １時的保管場所
__int64 *ptemp; // 上記のポインタ
__int64 *pend; // 上記の終点「__int64* temp; 」は、一時的にデータ配列の保管用
「__int64* ptemp;」は、上記への操作ポインタ
「__int64* pend; 」は、操作ポインタ終点
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (__int64*)malloc( sizeof(__int64) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「temp=(__int64*)malloc(sizeof(__int64)*(size+10));」は、
一時的データ配列の保管場所を動的に確保！
「if(temp==0){return(STI_MEM);}」は、メモリ確保失敗時
は、辺値「STI_MEM」を関数の値とし返し関数終了！
「ptemp=temp;pend=&temp[size];」は、確保した一時
バッファの操作用始終点をセット！
「while(ptemp<pend){*ptemp++=buf[*bufix++];}」は、
Ｗｈｉｌｅループ条件「ptemp<pend」で確保した一時
バッファの操作用始終点間を始点から終点まで繰り返し
「*ptemp++=buf[*bufix++];」とバッファへ元のデータ
配列を並び替えた物を格納します！
「up_movv(temp,buf,size);」は、並び替えた値の入って
居るバッファの内容を仮引数「__int64 buf[],」に格納する
事で並び替えを完了！
「free(temp);」は、一時的に確保したバッファを確保し
たシステムに返す！
「return(END_STI);」は、正常終了を辺値で返し関数終了！
（Ｅ）関数「SortCopy()」の【備考】
字面だけの判断≪筆者が、ド貧乏に成った為、検証させる
コンパイラ＆実行環境が用意出来無いので解説『
投げ銭方式ライブラリのダウンロード』に記載した様に
コンパイラ＆実行環境が整うまで実際の検証は無理≫ですが
明らかにミス≪バグ≫を見つけてシマッタ？！
「up_movv(temp,buf,size);」は、正しくは、
「up_movv(temp,buf,size*sizeof(__int64));」と記載し
無ければ、データを内部バッファから結果を完全にコピー
出来無い筈です！
★言い訳★ライブラリ作者≪詰り、筆者の私≫が、
「__int64型」の存在を知ったのは、２１世紀に成ってから
で特に直ぐ使う事に成るとは、考えて無かったので検証を
疎かにしたと思えます！
（４－１４－９９）関数「int SortCopy(void* buf[],
int bufix[],int size){・・・｝」
/************************************************************************/
/***** ソートした添字に従い並び替える関数：void* *****/
/************************************************************************/
int CopyClear::SortCopy(
void* buf[], // 並び替え対象
int bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){
void** temp; // １時的保管場所
void** ptemp; // 上記のポインタ
void** pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (void**)malloc( sizeof(void*) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, sizeof(void*) * size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear120」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortCopy()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Copy」は、勿論、カタカナ語コピーとして、ここでは、
関数「SortIndex()」でキー配列に連動して並び替えられた
インデックス配列を使用してコピーする事で指定した配列を
並び替える関数です！
（Ｂ）関数「int Sort()」の【返値】
中で作業用のバッファ領域を動的に確保します！その確保が
成功したら、処理し、最後に正常終了として「END_STI」を
辺値として返し、メモリ確保に失敗したら
エラーコードとして「STI_MEM」を辺値として返します！
（Ｃ）関数「SortCopy()」の【仮引数】
){
void** temp; // １時的保管場所
void** ptemp; // 上記のポインタ
void** pend; // 上記の終点「void* buf[],」は、インデックス配列に依って並び替える
配列！
「int bufix[],」は、関数「SortIndex()」でキー配列に
連動して並び替えられたインデックス配列★備考★ここでは
「int型」なので制約個数無しのインデックス配列です！
「int size」は、並び変える配列の数！
（Ｄ）関数「SortCopy()」の【アルゴリズム】
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (void**)malloc( sizeof(void*) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, sizeof(void*) * size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
void** temp; // １時的保管場所
void** ptemp; // 上記のポインタ
void** pend; // 上記の終点「void** temp; 」は、一時的にデータ配列の保管用
「void** ptemp;」は、上記への操作ポインタ
「void** pend; 」は、操作ポインタ終点
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (void**)malloc( sizeof(void*) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, sizeof(void*) * size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「temp=(void**)malloc(sizeof(void*)*(size+10));」は、
一時的データ配列の保管場所を動的に確保！
「if(temp==0){return(STI_MEM);}」は、メモリ確保失敗時
は、辺値「STI_MEM」を関数の値とし返し関数終了！
「ptemp=temp;pend=&temp[size];」は、確保した一時
バッファの操作用始終点をセット！
「while(ptemp<pend){*ptemp++=buf[*bufix++];}」は、
Ｗｈｉｌｅループ条件「ptemp<pend」で確保した一時
バッファの操作用始終点間を始点から終点まで繰り返し
「*ptemp++=buf[bufix++];」とバッファへ元のデータ
配列を並び替えた物を格納します！
「up_movv(temp,buf,sizeof(void)size);」は、並び替え
た値の入って居るバッファの内容を仮引数「void buf[],」
に格納する事で並び替えを完了！
「free(temp);」は、一時的に確保したバッファを確保し
たシステムに返す！
「return(END_STI);」は、正常終了を辺値で返し関数終了！
（４－１４－１００）関数「int SortCopy(TypeXY buf[],
int bufix[],int size){・・・｝」
/************************************************************************/
/***** ソートした添字に従い並び替える関数：TypeXY *****/
/************************************************************************/
int CopyClear::SortCopy(
TypeXY buf[], // 並び替え対象
int bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){
TypeXY *temp; // １時的保管場所
TypeXY *ptemp; // 上記のポインタ
TypeXY *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (TypeXY*)malloc( sizeof(TypeXY) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, sizeof(TypeXY) * size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear120」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortCopy()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Copy」は、勿論、カタカナ語コピーとして、ここでは、
関数「SortIndex()」でキー配列に連動して並び替えられた
インデックス配列を使用してコピーする事で指定した配列を
並び替える関数です！
（Ｂ）関数「int Sort()」の【返値】
中で作業用のバッファ領域を動的に確保します！その確保が
成功したら、処理し、最後に正常終了として「END_STI」を
辺値として返し、メモリ確保に失敗したら
エラーコードとして「STI_MEM」を辺値として返します！
（Ｃ）関数「SortCopy()」の【仮引数】
int CopyClear::SortCopy(
TypeXY buf[], // 並び替え対象
int bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){「TypeXY buf[],」は、インデックス配列に依って並び替える
配列！
「int bufix[],」は、関数「SortIndex()」でキー配列に
連動して並び替えられたインデックス配列★備考★ここでは
「int型」なので制約個数無しのインデックス配列です！
「int size」は、並び変える配列の数！
（Ｄ）関数「SortCopy()」の【アルゴリズム】
){
TypeXY *temp; // １時的保管場所
TypeXY *ptemp; // 上記のポインタ
TypeXY *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (TypeXY*)malloc( sizeof(TypeXY) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, sizeof(TypeXY) * size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
TypeXY *temp; // １時的保管場所
TypeXY *ptemp; // 上記のポインタ
TypeXY *pend; // 上記の終点「TypeXY* temp; 」は、一時的にデータ配列の保管用
「TypeXY* ptemp;」は、上記への操作ポインタ
「TypeXY* pend; 」は、操作ポインタ終点
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (TypeXY*)malloc( sizeof(TypeXY) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, sizeof(TypeXY) * size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「temp=(TypeXY*)malloc(sizeof(TypeXY)*(size+10));」は、
一時的データ配列の保管場所を動的に確保！
「if(temp==0){return(STI_MEM);}」は、メモリ確保失敗時
は、辺値「STI_MEM」を関数の値とし返し関数終了！
「ptemp=temp;pend=&temp[size];」は、確保した一時
バッファの操作用始終点をセット！
「while(ptemp<pend){*ptemp++=buf[*bufix++];}」は、
Ｗｈｉｌｅループ条件「ptemp<pend」で確保した一時
バッファの操作用始終点間を始点から終点まで繰り返し
「*ptemp++=buf[*bufix++];」とバッファへ元のデータ
配列を並び替えた物を格納します！
「up_movv(temp,buf,sizeof(TypeXY)*size);」は、並び
替えた値の入って居るバッファの内容を仮引数「
TypeXY buf[],」に格納する事で並び替えを完了！
「free(temp);」は、一時的に確保したバッファを確保し
たシステムに返す！
「return(END_STI);」は、正常終了を辺値で返し関数終了！
（４－１４－１０１）関数「int SortCopy(TypeXYI buf[],
int bufix[],int size){・・・｝」
/************************************************************************/
/***** ソートした添字に従い並び替える関数：TypeXYI *****/
/************************************************************************/
int CopyClear::SortCopy(
TypeXYI buf[], // 並び替え対象
int bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){
TypeXYI *temp; // １時的保管場所
TypeXYI *ptemp; // 上記のポインタ
TypeXYI *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (TypeXYI*)malloc( sizeof(TypeXYI) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, sizeof(TypeXYI) * size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear120」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortCopy()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Copy」は、勿論、カタカナ語コピーとして、ここでは、
関数「SortIndex()」でキー配列に連動して並び替えられた
インデックス配列を使用してコピーする事で指定した配列を
並び替える関数です！
（Ｂ）関数「int Sort()」の【返値】
中で作業用のバッファ領域を動的に確保します！その確保が
成功したら、処理し、最後に正常終了として「END_STI」を
辺値として返し、メモリ確保に失敗したら
エラーコードとして「STI_MEM」を辺値として返します！
（Ｃ）関数「SortCopy()」の【仮引数】
int CopyClear::SortCopy(
TypeXYI buf[], // 並び替え対象
int bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){「TypeXYI buf[],」は、インデックス配列に依って並び替える
配列！
「int bufix[],」は、関数「SortIndex()」でキー配列に
連動して並び替えられたインデックス配列★備考★ここでは
「int型」なので制約個数無しのインデックス配列です！
「int size」は、並び変える配列の数！
（Ｄ）関数「SortCopy()」の【アルゴリズム】
){
TypeXYI *temp; // １時的保管場所
TypeXYI *ptemp; // 上記のポインタ
TypeXYI *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (TypeXYI*)malloc( sizeof(TypeXYI) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, sizeof(TypeXYI) * size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
TypeXYI *temp; // １時的保管場所
TypeXYI *ptemp; // 上記のポインタ
TypeXYI *pend; // 上記の終点「TypeXYI* temp; 」は、一時的にデータ配列の保管用
「TypeXYI* ptemp;」は、上記への操作ポインタ
「TypeXYI* pend; 」は、操作ポインタ終点
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (TypeXYI*)malloc( sizeof(TypeXYI) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, sizeof(TypeXYI) * size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「temp=(TypeXYI*)malloc(sizeof(TypeXYI)*(size+10));」は、
一時的データ配列の保管場所を動的に確保！
「if(temp==0){return(STI_MEM);}」は、メモリ確保失敗時
は、辺値「STI_MEM」を関数の値とし返し関数終了！
「ptemp=temp;pend=&temp[size];」は、確保した一時
バッファの操作用始終点をセット！
「while(ptemp<pend){*ptemp++=buf[*bufix++];}」は、
Ｗｈｉｌｅループ条件「ptemp<pend」で確保した一時
バッファの操作用始終点間を始点から終点まで繰り返し
「*ptemp++=buf[*bufix++];」とバッファへ元のデータ
配列を並び替えた物を格納します！
「up_movv(temp,buf,sizeof(TypeXYI)*size);」は、並び
替えた値の入って居るバッファの内容を仮引数「
TypeXYI buf[],」に格納する事で並び替えを完了！
「free(temp);」は、一時的に確保したバッファを確保し
たシステムに返す！
「return(END_STI);」は、正常終了を辺値で返し関数終了！
（４－１４－１０２）関数「int SortCopy(TypeXYHV buf[],
int bufix[],int size){・・・｝」
/************************************************************************/
/***** ソートした添字に従い並び替える関数：TypeXYHV *****/
/************************************************************************/
int CopyClear::SortCopy(
TypeXYHV buf[], // 並び替え対象
int bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){
TypeXYHV *temp; // １時的保管場所
TypeXYHV *ptemp; // 上記のポインタ
TypeXYHV *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (TypeXYHV*)malloc( sizeof(TypeXYHV) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, sizeof(TypeXYHV) * size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}☆備考☆この関数はファイル「CopyClear120」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
★注意★この関数には、同名で仮引数が異なるオーバーロー
ド（多重定義）関数が存在します！
（Ａ）関数「SortCopy()」の【関数名】
「Sort」は、勿論、英単語「sort」、カタカナ語ソート・
ソーティング、詰り並び替えです、
「Copy」は、勿論、カタカナ語コピーとして、ここでは、
関数「SortIndex()」でキー配列に連動して並び替えられた
インデックス配列を使用してコピーする事で指定した配列を
並び替える関数です！
（Ｂ）関数「int Sort()」の【返値】
中で作業用のバッファ領域を動的に確保します！その確保が
成功したら、処理し、最後に正常終了として「END_STI」を
辺値として返し、メモリ確保に失敗したら
エラーコードとして「STI_MEM」を辺値として返します！
（Ｃ）関数「SortCopy()」の【仮引数】
int CopyClear::SortCopy(
TypeXYHV buf[], // 並び替え対象
int bufix[], // 添字部Bufferのptr
int size // Bufferのサイズ
){「TypeXYHV buf[],」は、インデックス配列に依って並び替える
配列！
「int bufix[],」は、関数「SortIndex()」でキー配列に
連動して並び替えられたインデックス配列★備考★ここでは
「int型」なので制約個数無しのインデックス配列です！
「int size」は、並び変える配列の数！
（Ｄ）関数「SortCopy()」の【アルゴリズム】
){
TypeXYHV *temp; // １時的保管場所
TypeXYHV *ptemp; // 上記のポインタ
TypeXYHV *pend; // 上記の終点
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (TypeXYHV*)malloc( sizeof(TypeXYHV) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, sizeof(TypeXYHV) * size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}（Ｄ－１）ローカル変数
){
TypeXYHV *temp; // １時的保管場所
TypeXYHV *ptemp; // 上記のポインタ
TypeXYHV *pend; // 上記の終点「TypeXYHV* temp; 」は、一時的にデータ配列の保管用
「TypeXYHV* ptemp;」は、上記への操作ポインタ
「TypeXYHV* pend; 」は、操作ポインタ終点
（Ｄ－２）アルゴリズムコード
if( size <= 0 ){ // サイズが０以下
return( END_STI ); // 正常終了
} //
temp = (TypeXYHV*)malloc( sizeof(TypeXYHV) // Bufferを確保
* ( size + 10 ) ); //
if( temp == 0 ){ // 確保失敗ならば
return( STI_MEM ); // 左記を返す
} //
ptemp = temp; // １時保管場所の
pend = &temp[ size ]; // 始終点をセット
while( ptemp < pend ){ // 始終点間で元の
*ptemp++ = buf[ *bufix++ ]; // Bufferの内容を
} // 並び替える
up_movv( temp, buf, sizeof(TypeXYHV) * size ); // 元のBufferへCopy
free( temp ); // Tempを解放し
return( END_STI ); // 正常終了
}「if(size<=0){return(END_STI);}」は、データのサイズが
０以下ならば、処理せずに正常終了！
「temp=(TypeXYHV*)malloc(sizeof(TypeXYHV)*(size+10));」は、
一時的データ配列の保管場所を動的に確保！
「if(temp==0){return(STI_MEM);}」は、メモリ確保失敗時
は、辺値「STI_MEM」を関数の値とし返し関数終了！
「ptemp=temp;pend=&temp[size];」は、確保した一時
バッファの操作用始終点をセット！
「while(ptemp<pend){*ptemp++=buf[*bufix++];}」は、
Ｗｈｉｌｅループ条件「ptemp<pend」で確保した一時
バッファの操作用始終点間を始点から終点まで繰り返し
「*ptemp++=buf[*bufix++];」とバッファへ元のデータ
配列を並び替えた物を格納します！
「up_movv(temp,buf,sizeof(TypeXYHV)*size);」は、並び
替えた値の入って居るバッファの内容を仮引数「
TypeXYHV buf[],」に格納する事で並び替えを完了！
「free(temp);」は、一時的に確保したバッファを確保し
たシステムに返す！
「return(END_STI);」は、正常終了を辺値で返し関数終了！
本日（１月２４）の講義はココまでとします！
流石に新しくと言うか大量の解説なので受講者の皆様が、
消化出来る為にココまでとします！
次から、【ソーティング小技】系の関数の解説に成るので
新しく新規解説『解説クラスＣｏｐｙＣｌｅａｒ（２０）』
として近々、始めますので宜しく、御贔屓の程、お願いしま
す！