解説クラスＣｏｐｙＣｌｅａｒ（２２）
解説クラスＣｏｐｙＣｌｅａｒ（２２）
【座標組データ操作】系の関数の解説を行います！
この講義は解説『解説クラスＣｏｐｙＣｌｅａｒ（２１）』
の続きです！
２０２５年２月３初講（初稿）
（４－１４－１１９）関数「void ConvertXY2int(TypeXY xy[],
int buf[],int size,int mode) {・・・｝」
/************************************************************************/
/***** ＳＯＲＴ補助：「TypeXY」から「int」への 変換*****/
/************************************************************************/
void CopyClear::ConvertXY2int(
TypeXY xy[], // 元のTypeXYバッファー
int buf[], // 変換先のintバッファー
int size, // バッファーサイズ
int mode // モード
// 0:XY→int
// 1:YX→int（省略時）
){
if( mode == 0 ){ // ＸＹ変換ならば
for( ; --size >= 0; xy++ ){ // サイズ分
*buf++ = ( xy->x << 16 ) | xy->y ; // Ｘ×0x10000＋Ｙ変換
} //
}else if( mode == 1 ){ // ＸＹ変換ならば
for( ; --size >= 0; xy++ ){ // サイズ分
*buf++ = xy->x | ( xy->y << 16 ); // Ｙ×0x10000＋Ｘ変換
} //
} //
}☆備考☆この関数はファイル「CopyClear110」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
（Ａ）関数「ConvertXY2int()」の【関数名】
「Convert」は、英単語「Convert」として変換するの意味で
す！
「XY」は、「ＸＹ座標」、ここでは「TypeXY xy[],」は、
「TypeXY 型」と「座標組型」≪解説『解説クラス
Ｓｕｐｐｏｒｔ』の中で「（２）構造体「struct構文で
定義」したデータ構造」の更に「（２－１）座標組用データ
構造」で説明？！≫
「2」は、英単語「to」と発音が近いので「to」の省略と
して使用！
「int」は、勿論、「int型」４バイト整数型です！
ここでは、「TypeXY 型」のデータを「int型」に
ソーティング用の補助関数として変換する関数です！
（Ｂ）関数「void ConvertXY2int()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「ConvertXY2int()」の【仮引数】
void CopyClear::ConvertXY2int(
TypeXY xy[], // 元のTypeXYバッファー
int buf[], // 変換先のintバッファー
int size, // バッファーサイズ
int mode // モード
// 0:XY→int
// 1:YX→int（省略時）
){「TypeXY xy[],」は、「ＸＹ座標」、ここでは「TypeXY 型
」と「座標組型」≪解説『解説クラスＳｕｐｐｏｒｔ』の中
で「（２）構造体「struct構文で定義」したデータ構造」の
更に「（２－１）座標組用データ構造」で説明？！≫
「int buf[],」は、「int型」４バイト整数型の配列
「int size,」は、配列のサイズ
「int mode」は、「mode＝0」で「xy[]からbuf[]への変換が
メンバー変数【x】が上位１６ビットでメンバー変数【y】が
下位１６ビット」そして「mode＝1」で「xy[]からbuf[]への
変換がメンバー変数【y】が上位１６ビットでメンバー
変数【x】が下位１６ビット」に成るモード選択です！
（Ｄ）関数「ConvertXY2int()」の【アルゴリズム】
){
if( mode == 0 ){ // ＸＹ変換ならば
for( ; --size >= 0; xy++ ){ // サイズ分
*buf++ = ( xy->x << 16 ) | xy->y ; // Ｘ×0x10000＋Ｙ変換
} //
}else if( mode == 1 ){ // ＸＹ変換ならば
for( ; --size >= 0; xy++ ){ // サイズ分
*buf++ = xy->x | ( xy->y << 16 ); // Ｙ×0x10000＋Ｘ変換
} //
} //
}「if(mode==0){for(;--size>=0;xy++){
*buf++=(xy->x<<16)|xy->y;}}」は、条件「if(mode==0)」で
「xy[]からbuf[]への変換として中身のｆｏｒループ
「for(;--size>=0;xy++){*buf++=(xy->x<<16)|xy->y;}」と
ループ中身「*buf++=(xy->x<<16)|xy->y;」で
「xy->xy<<16」とＸ座標成分を上位１６ビットに
「|xy->y」とＹ座標成分を下位１６ビットに「int型」
４バイトに纏め上げた処理を行う！★備考★ｆｏｒ構文
「--size>=0;」で「size」個数ループを繰り返し、
「xy++」で「TypeXY 型」ポインタを次へ進めている事は
理解されて居ると思います！尚、「*buf++=」と「int型」
のポインタの場合は、この記載で高速なコンパイラコードが
生成されるので「*buf++」を使用していますのでｆｏｒ
ループ構文「xy++」とループ本体後置でポインタを進める
処理は行いません！
「else if(mode==1){for(;--size>=0;xy++){
*buf++=xy->x|(xy->y<<16);}}」は、
条件「else if(mode==1)」で「buf[]からxy[]への変換として
中身のｆｏｒループ「for(;--size>=0;xy++){
*buf++=xy->x|(xy->y<<16);}」とループ中身
「*buf++=xy->x|(xy->y<<16);」でＸ座標成分を下位１６
ビットにＹ座標成分を上位１６ビットに「int型」４バイト
に纏め上げた処理を行う！
（４－１４－１２０）関数「void ConvertXYHV2int(
TypeXYHV xy[],int buf[],
int size,int mode) {・・・｝」
/************************************************************************************/
/***** ＳＯＲＴ補助：「TypeXYHV」から「int」への変換 *****/
/***** ※注意※ 増加幅「inc」＝０（省略時）の時は、「int」を16bit+16bitに *****/
/***** ※注意※ 分割して格納しますが、増加幅「inc」を指定すると任意の組み *****/
/***** ※注意※ 合わせで格納できます。 *****/
/************************************************************************************/
void CopyClear::ConvertXYHV2int(
TypeXYHV xy[], // 元のTypeXYHVバッファー
int buf[], // 変換先のintバッファー
int size, // バッファーサイズ
int mode, // モード
// 0:XY→int
// 1:YX→int（省略時）
// 2:HV→int
// 3:VH→int
// 4:YV→int
int inc // 増加幅（0:省略時目印）
){
if( inc == 0 ){ // 増加幅省略時は
if( mode == 0 ){ // ＸＹ変換ならば
for( ; --size >= 0; xy++ ){ // サイズ分
*buf++ = ( xy->x << 16 ) | xy->y ; // Ｘ×0x10000＋Ｙ変換
} //
}else if( mode == 1 ){ // ＸＹ変換ならば
for( ; --size >= 0; xy++ ){ // サイズ分
*buf++ = ( xy->y << 16 ) | xy->x; // Ｙ×0x10000＋Ｘ変換
} //
}else if( mode == 2 ){ // ＨＶ変換ならば
for( ; --size >= 0; xy++ ){ // サイズ分
*buf++ = ( xy->h << 16 ) | xy->v; // Ｈ×0x10000＋Ｖ変換
} //
}else if( mode == 3 ){ // ＶＨ変換ならば
for( ; --size >= 0; xy++ ){ // サイズ分
*buf++ = ( xy->v << 16 ) | xy->h; // Ｖ×0x10000＋Ｈ変換
} //
}else if( mode == 4 ){ // ＹＶ変換ならば
for( ; --size >= 0; xy++ ){ // サイズ分
*buf++ = ( xy->y << 16 ) | xy->v; // Ｙ×0x10000＋Ｖ変換
} //
} //
}else{ // 増加幅設定時は
if( mode == 0 ){ // ＸＹ変換ならば
for( ; --size >= 0; xy++ ){ // サイズ分
*buf++ = xy->x * inc + xy->y; // Ｘ×増加幅＋Ｙ変換
} //
}else if( mode == 1 ){ // ＸＹ変換ならば
for( ; --size >= 0; xy++ ){ // サイズ分
*buf++ = xy->y * inc + xy->x; // Ｙ×増加幅＋Ｘ変換
} //
}else if( mode == 2 ){ // ＨＶ変換ならば
for( ; --size >= 0; xy++ ){ // サイズ分
*buf++ = xy->h * inc + xy->v; // Ｈ×増加幅＋Ｖ変換
} //
}else if( mode == 3 ){ // ＶＨ変換ならば
for( ; --size >= 0; xy++ ){ // サイズ分
*buf++ = xy->v * inc + xy->h; // Ｖ×増加幅＋Ｈ変換
} //
}else if( mode == 4 ){ // ＹＶ変換ならば
for( ; --size >= 0; xy++ ){ // サイズ分
*buf++ = xy->y * inc + xy->v; // Ｙ×増加幅＋Ｖ変換
} //
} //
} //
}☆備考☆この関数はファイル「CopyClear110」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
（Ａ）関数「ConvertXYHV2int()」の【関数名】
「Convert」は、英単語「Convert」として変換するの意味で
す！
「XY」は、「ＸＹ座標」、ここでは「TypeXYHV xy[],」は、
「TypeXYHV 型」と「座標組型」≪解説『解説クラス
Ｓｕｐｐｏｒｔ』の中で「（２）構造体「struct構文で
定義」したデータ構造」の更に「（２－３）座標矩形範囲用
データ構造」で説明？！≫
「2」は、英単語「to」と発音が近いので「to」の省略と
して使用！
「int」は、勿論、「int型」４バイト整数型です！
ここでは、「TypeXYHV 型」のデータを「int型」に
ソーティング用の補助関数として変換する関数です！
（Ｂ）関数「void ConvertXYHV2int()」の【返値】
返値を返さない関数です！
★注意★詰り、実引数の検査を実行時に行いませんので
使用する時は、正しい実引数を記載する必要が有ります！
（Ｃ）関数「ConvertXYHV2int()」の【仮引数】
void CopyClear::ConvertXYHV2int(
TypeXYHV xy[], // 元のTypeXYHVバッファー
int buf[], // 変換先のintバッファー
int size, // バッファーサイズ
int mode, // モード
// 0:XY→int
// 1:YX→int（省略時）
// 2:HV→int
// 3:VH→int
// 4:YV→int
int inc // 増加幅（0:省略時目印）
){「TypeXYHV xy[],」は、「ＸＹ座標」、ここでは「TypeXYHV 型」と「座標組型」≪解説『解説クラスＳｕｐｐｏｒｔ』の中で「（２）構造体「struct構文で定義」したデータ構造」の
更に「（２－３）座標矩形範囲用データ構造」で説明？！≫
「int buf[],」は、「int型」４バイト整数型の配列
「int size,」は、配列のサイズ
「int mode,」は、「mode＝0」で「xy[]からbuf[]への変換が
メンバー変数【x】が上位１６ビットでメンバー変数【y】が
下位１６ビット」★備考★この「上位下位１６ビット」に
分けるのは、次に説明する引数「int inc」が「inc＝０」の
場合（デフォルト）で「inc≠０」では、増加幅として
下駄上げ≪incで指定した任意の数を乗算し嵩上げ≫した
値を変数【x】に適応し変数【y】にはそのママの値を合成！
そして「mode＝1」で「xy[]からbuf[]への変換がメンバー
変数【y】が上位１６ビットでメンバー変数【x】が下位１６
ビット」に成るモード選択です！★備考★引数「int inc」
の事は、ココでも影響します！意味は、「mode＝0」の備考
を参考にして下さい！
そして「mode＝2」で「xy[]からbuf[]への変換が
メンバー変数【h】が上位１６ビットでメンバー変数【v】が
下位１６ビット」★備考★引数「int inc」
の事は、ココでも影響します！意味は、「mode＝0」の備考
を参考にして下さい！
そして「mode＝3」で「xy[]からbuf[]への変換がメンバー
変数【v】が上位１６ビットでメンバー変数【h】が下位１６
ビット」に成るモード選択です！★備考★引数「int inc」
の事は、ココでも影響します！意味は、「mode＝0」の備考
を参考にして下さい！
そして「mode＝4」で「xy[]からbuf[]への変換がメンバー
変数【y】が上位１６ビットでメンバー変数【v】が下位１６
ビット」に成るモード選択です！★備考★引数「int inc」
の事は、ココでも影響します！意味は、「mode＝0」の備考
を参考にして下さい！
「int inc」は、「inc＝０」の場合（デフォルト）で
「mode＝0」の所の備考で説明した増加幅として上位下位
１６ビット合成しますが、「inc≠０」では、下駄上げ≪
incで指定した任意の数を乗算し嵩上げ≫した値を変数【x】
に適応し変数【y】にはそのママの値を合成！等と下駄揚げ
に使用！
（Ｄ）関数「ConvertXYHV2int()」の【アルゴリズム】
){
if( inc == 0 ){ // 増加幅省略時は
if( mode == 0 ){ // ＸＹ変換ならば
for( ; --size >= 0; xy++ ){ // サイズ分
*buf++ = ( xy->x << 16 ) | xy->y ; // Ｘ×0x10000＋Ｙ変換
} //
}else if( mode == 1 ){ // ＸＹ変換ならば
for( ; --size >= 0; xy++ ){ // サイズ分
*buf++ = ( xy->y << 16 ) | xy->x; // Ｙ×0x10000＋Ｘ変換
} //
}else if( mode == 2 ){ // ＨＶ変換ならば
for( ; --size >= 0; xy++ ){ // サイズ分
*buf++ = ( xy->h << 16 ) | xy->v; // Ｈ×0x10000＋Ｖ変換
} //
}else if( mode == 3 ){ // ＶＨ変換ならば
for( ; --size >= 0; xy++ ){ // サイズ分
*buf++ = ( xy->v << 16 ) | xy->h; // Ｖ×0x10000＋Ｈ変換
} //
}else if( mode == 4 ){ // ＹＶ変換ならば
for( ; --size >= 0; xy++ ){ // サイズ分
*buf++ = ( xy->y << 16 ) | xy->v; // Ｙ×0x10000＋Ｖ変換
} //
} //
}else{ // 増加幅設定時は
if( mode == 0 ){ // ＸＹ変換ならば
for( ; --size >= 0; xy++ ){ // サイズ分
*buf++ = xy->x * inc + xy->y; // Ｘ×増加幅＋Ｙ変換
} //
}else if( mode == 1 ){ // ＸＹ変換ならば
for( ; --size >= 0; xy++ ){ // サイズ分
*buf++ = xy->y * inc + xy->x; // Ｙ×増加幅＋Ｘ変換
} //
}else if( mode == 2 ){ // ＨＶ変換ならば
for( ; --size >= 0; xy++ ){ // サイズ分
*buf++ = xy->h * inc + xy->v; // Ｈ×増加幅＋Ｖ変換
} //
}else if( mode == 3 ){ // ＶＨ変換ならば
for( ; --size >= 0; xy++ ){ // サイズ分
*buf++ = xy->v * inc + xy->h; // Ｖ×増加幅＋Ｈ変換
} //
}else if( mode == 4 ){ // ＹＶ変換ならば
for( ; --size >= 0; xy++ ){ // サイズ分
*buf++ = xy->y * inc + xy->v; // Ｙ×増加幅＋Ｖ変換
} //
} //
} //
}「if(inc==0){・・成立中身・・}else{・・不成立中身・・}」
は、「inc＝０」の場合（デフォルト）で成立中身を処理し、
「inc≠０」の場合で不成立中身を処理します！
（１）成立中身
（１－１）条件「if(mode==0){・・中身・・}」の中身
「for(;--size>=0;xy++){*buf++=(xy->x<<16)|xy->y;}」は、
ｆｏｒループ構文「for(;--size>=0;xy++){・ループ中身・}
」とループ条件「--size>=0;」でサイズ分配列全体、
ループ後置「xy++」でポインタの「xy」を次へ進める、
ポインタを進める「*buf++=」とループ中身で代入と同時に
進める事で高速な機械コード生成の為に記載しています！
で中身「*buf++=(xy->x<<16)|xy->y;」の代入する
式「(xy->x<<16)|xy->y;」で「xy->x」とＸ座標メンバー
変数を「x<<16」と１６ビット整数型上位２バイトに
「|xy->y;」で「xy->y」とＹ座標メンバー変数を
「|xy->y;」と１６ビット整数型下位２バイトに合成し、
「*buf++=」と代入します！
（１－２）条件「else if(mode==1){・・中身・・}」の中身
「for(;--size>=0;xy++){*buf++=(xy->y<<16)|xy->x;}」は、
ｆｏｒループ構文「for(;--size>=0;xy++){・ループ中身・}
」とループ条件「--size>=0;」でサイズ分配列全体、
ループ後置「xy++」でポインタの「xy」を次へ進める、
ポインタを進める「*buf++=」とループ中身で代入と同時に
進める事で高速な機械コード生成の為に記載しています！
で中身「*buf++=(xy->y<<16)|xy->x;}」の代入する
式「(xy->y<<16)|xy->x;」で「xy->x」とＹ座標メンバー
変数を「y<<16」と１６ビット整数型上位２バイトに
「|xy->x;」で「xy->x」とＸ座標メンバー変数を
「|xy->x;」と１６ビット整数型下位２バイトに合成し、
「*buf++=」と代入します！
（１－３）条件「else if(mode==2){・・中身・・}」の中身
「for(;--size>=0;xy++){*buf++=(xy->h<<16)|xy->v;}」は、
ｆｏｒループ構文「for(;--size>=0;xy++){・ループ中身・}
」とループ条件「--size>=0;」でサイズ分配列全体、
ループ後置「xy++」でポインタの「xy」を次へ進める、
ポインタを進める「*buf++=」とループ中身で代入と同時に
進める事で高速な機械コード生成の為に記載しています！
で中身「*buf++=(xy->h<<16)|xy->v;}」の代入する
式「(xy->h<<16)|xy->v;」で「xy->h」と水平幅メンバー
変数を「h<<16」と１６ビット整数型上位２バイトに
「|xy->v;」で「xy->v」と垂直幅メンバー変数を
「|xy->v;」と１６ビット整数型下位２バイトに合成し、
「*buf++=」と代入します！
（１－４）条件「else if(mode==3){・・中身・・}」の中身
「for(;--size>=0;xy++){*buf++=(xy->v<<16)|xy->h;}」は、
ｆｏｒループ構文「for(;--size>=0;xy++){・ループ中身・}
」とループ条件「--size>=0;」でサイズ分配列全体、
ループ後置「xy++」でポインタの「xy」を次へ進める、
ポインタを進める「*buf++=」とループ中身で代入と同時に
進める事で高速な機械コード生成の為に記載しています！
で中身「*buf++=(xy->v<<16)|xy->h;}」の代入する
式「(xy->v<<16)|xy->h;」で「xy->v」と垂直幅メンバー
変数を「y<<16」と１６ビット整数型上位２バイトに
「|xy->h;」で「xy->h」と水平幅メンバー変数を
「|xy->h;」と１６ビット整数型下位２バイトに合成し、
「*buf++=」と代入します！
（１－５）条件「else if(mode==4){・・中身・・}」の中身
「for(;--size>=0;xy++){*buf++=(xy->y<<16)|xy->v;}」は、
ｆｏｒループ構文「for(;--size>=0;xy++){・ループ中身・}
」とループ条件「--size>=0;」でサイズ分配列全体、
ループ後置「xy++」でポインタの「xy」を次へ進める、
ポインタを進める「*buf++=」とループ中身で代入と同時に
進める事で高速な機械コード生成の為に記載しています！
で中身「*buf++=(xy->y<<16)|xy->v;}」の代入する
式「(xy->y<<16)|xy->v;」で「xy->v」とＹ座標メンバー
変数を「y<<16」と１６ビット整数型上位２バイトに
「|xy->v;」で「xy->v」と垂直幅メンバー変数を
「|xy->v;」と１６ビット整数型下位２バイトに合成し、
「buf++=」と代入します！
（２）不成立中身
（２－１）条件「if(mode==0){・・中身・・}」の中身
「for(;--size>=0;xy++){buf++=xy->x inc+xy->y;}」は、
ｆｏｒループ構文「for(;--size>=0;xy++){・ループ中身・}
」とループ条件「--size>=0;」でサイズ分配列全体、
ループ後置「xy++」でポインタの「xy」を次へ進める、
ポインタを進める「buf++=」とループ中身で代入と同時に
進める事で高速な機械コード生成の為に記載しています！
で中身「buf++=xy->x inc+xy->y;」の代入する
式「(xy->x inc+xy->y;」で「xy->x」とＸ座標メンバー
変数を「x inc」と任意増加幅「inc」で下駄揚げ
「|xy->y;」で「xy->y」とＹ座標メンバー変数を
「|xy->y;」とそのママの値で合成し、
「buf++=」と代入します！
（２－２）条件「else if(mode==1){・・中身・・}」の中身
「for(;--size>=0;xy++){buf++=xy->y inc+xy->x;}」は、
ｆｏｒループ構文「for(;--size>=0;xy++){・ループ中身・}
」とループ条件「--size>=0;」でサイズ分配列全体、
ループ後置「xy++」でポインタの「xy」を次へ進める、
ポインタを進める「buf++=」とループ中身で代入と同時に
進める事で高速な機械コード生成の為に記載しています！
で中身「buf++=xy->y inc+xy->x;}」の代入する
式「(xy->y inc+xy->x;」で「xy->x」とＹ座標メンバー
変数を「y inc」と任意増加幅「inc」で下駄揚げ
「|xy->x;」で「xy->x」とＸ座標メンバー変数を
「|xy->x;」とそのママの値で合成し、
「buf++=」と代入します！
（２－３）条件「else if(mode==2){・・中身・・}」の中身
「for(;--size>=0;xy++){buf++=xy->h inc+xy->v;}」は、
ｆｏｒループ構文「for(;--size>=0;xy++){・ループ中身・}
」とループ条件「--size>=0;」でサイズ分配列全体、
ループ後置「xy++」でポインタの「xy」を次へ進める、
ポインタを進める「buf++=」とループ中身で代入と同時に
進める事で高速な機械コード生成の為に記載しています！
で中身「buf++=xy->h inc+xy->v;}」の代入する
式「(xy->h inc+xy->v;」で「xy->h」と水平幅メンバー
変数を「h inc」と任意増加幅「inc」で下駄揚げ
「|xy->v;」で「xy->v」と垂直幅メンバー変数を
「|xy->v;」とそのママの値で合成し、
「buf++=」と代入します！
（２－４）条件「else if(mode==3){・・中身・・}」の中身
「for(;--size>=0;xy++){buf++=xy->v inc+xy->h;}」は、
ｆｏｒループ構文「for(;--size>=0;xy++){・ループ中身・}
」とループ条件「--size>=0;」でサイズ分配列全体、
ループ後置「xy++」でポインタの「xy」を次へ進める、
ポインタを進める「buf++=」とループ中身で代入と同時に
進める事で高速な機械コード生成の為に記載しています！
で中身「buf++=xy->v inc+xy->h;}」の代入する
式「(xy->v inc+xy->h;」で「xy->v」と垂直幅メンバー
変数を「y inc」と任意増加幅「inc」で下駄揚げ
「|xy->h;」で「xy->h」と水平幅メンバー変数を
「|xy->h;」とそのママの値で合成し、
「buf++=」と代入します！
（２－５）条件「else if(mode==4){・・中身・・}」の中身
「for(;--size>=0;xy++){buf++=xy->y inc+xy->v;}」は、
ｆｏｒループ構文「for(;--size>=0;xy++){・ループ中身・}
」とループ条件「--size>=0;」でサイズ分配列全体、
ループ後置「xy++」でポインタの「xy」を次へ進める、
ポインタを進める「buf++=」とループ中身で代入と同時に
進める事で高速な機械コード生成の為に記載しています！
で中身「buf++=xy->y inc+xy->v;}」の代入する
式「(xy->y inc+xy->v;」で「xy->v」とＹ座標メンバー
変数を「y inc」と任意増加幅「inc」で下駄揚げ
「|xy->v;」で「xy->v」と垂直幅メンバー変数を
「|xy->v;」とそのママの値で合成し、
「*buf++=」と代入します！
★備考★読んでいて疲れたでしょう？！Ｃ言語での数式に依
る表現の方が、私には、日本語の記載より判り易かったので
は無いかと思います！私のソースコードは右側に「//」で
ソースコードと混ざらない様に分離してコメントで左側の
Ｃ言語記載の説明を行っていますので確認して下さい！
更に関数の記載前にコメント行として大まかな説明を行って
います！
（４－１４－１２１）関数「int BinarySearchX(TypeXY buf[],
int size,int x) {・・・｝」
/********************************************************************************/
/***** ソート関連：TypeXYがＸ座標で昇順ソートしている時にＸ座標を探す *****/
/***** 関数返値：サーチしたIndex *****/
/********************************************************************************/
int CopyClear::BinarySearchX(
TypeXY buf[], // バッファー
int size, // バッファーサイズ
int x // 探査対象
){
int i; // 探査Index
int s; // 刻み
int d; // データ
for( i = 1; i < size; i *= 2 ){ // サイズの
; // 中心になるように
} // 探査Index
i /= 2; // 算出（２のベキ乗）
s = i / 2; // 刻み算出
for( ; s > 0; s /= 2 ){ // 以下を繰り返す
d = buf[i].x; // データを取り出し
if( d == x ){ // 探査終了したら
return( i ); // Indexを返す
}else if( d > x ){ // 大きければ
i -= s; // Index減少
}else{ // 小さければ
i += s; // Index増加
while( i >= size ){ // 最終Index Over時
s /= 2; // 刻み半分
i -= s; // Index減少
} //
} //
} //
return( i ); // 探査Indexを返す
}☆備考☆この関数はファイル「CopyClear130」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
（Ａ）関数「BinarySearchX()」の【関数名】
「Binary」は、英単語「Binary」で「広く２を表す」とか
「Search」は、英単語「Search」で「探す・探索」です！
「BinarySearch」でコンピューターサイエンス的には、
用語「バイナリーサーチ・二分探索」としてソート済みの
配列に対して目的のデータを探す事を意味します！
「X」は、Ｘ座標を示し、ココで使用する
仮引数「TypeXY buf[]」の「TypeXY型」、「座標組型」
≪解説『解説クラスＳｕｐｐｏｒｔ』の中で「（２）
構造体「struct構文で定義」したデータ構造」の更に
「（２－１）座標組用データ構造」で説明？！≫のＸ座標
に対して適応！
（Ｂ）関数「int BinarySearchX()」の【返値】
探索（サーチ）対象が発見された時の配列添え字（インデッ
クス）値を関数辺値とし返します！
（Ｃ）関数「BinarySearchX()」の【仮引数】
int CopyClear::BinarySearchX(
TypeXY buf[], // バッファー
int size, // バッファーサイズ
int x // 探査対象
){「TypeXY buf[],」は、探索（サーチ）対象の配列で
「TypeXY型」、「座標組型」≪解説『解説クラスＳｕｐｐｏ
ｒｔ』の中で「（２）構造体「struct構文で定義」した
データ構造」の更に「（２－１）座標組用データ構造」で
説明？！≫
「int size,」は、配列のサイズ
「int x」は、探索（サーチ）するＸ座標の値
（Ｄ）関数「BinarySearchX()」の【アルゴリズム】
){
int i; // 探査Index
int s; // 刻み
int d; // データ
for( i = 1; i < size; i *= 2 ){ // サイズの
; // 中心になるように
} // 探査Index
i /= 2; // 算出（２のベキ乗）
s = i / 2; // 刻み算出
for( ; s > 0; s /= 2 ){ // 以下を繰り返す
d = buf[i].x; // データを取り出し
if( d == x ){ // 探査終了したら
return( i ); // Indexを返す
}else if( d > x ){ // 大きければ
i -= s; // Index減少
}else{ // 小さければ
i += s; // Index増加
while( i >= size ){ // 最終Index Over時
s /= 2; // 刻み半分
i -= s; // Index減少
} //
} //
} //
return( i ); // 探査Indexを返す
}（Ｄ－１）ローカル変数
){
int i; // 探査Index
int s; // 刻み
int d; // データ「int i;」は、探査（サーチ）添え字（インデックス）
「int s;」は、探索ステップ刻み幅とし「step」からs名称
「int d;」は、比較データの一時、置き場
（Ｄ－２）アルゴリズムコード
for( i = 1; i < size; i *= 2 ){ // サイズの
; // 中心になるように
} // 探査Index
i /= 2; // 算出（２のベキ乗）
s = i / 2; // 刻み算出
for( ; s > 0; s /= 2 ){ // 以下を繰り返す
d = buf[i].x; // データを取り出し
if( d == x ){ // 探査終了したら
return( i ); // Indexを返す
}else if( d > x ){ // 大きければ
i -= s; // Index減少
}else{ // 小さければ
i += s; // Index増加
while( i >= size ){ // 最終Index Over時
s /= 2; // 刻み半分
i -= s; // Index減少
} //
} //
} //
return( i ); // 探査Indexを返す
}「for(i=1;i<size;i*=2){;}」は、「1,2,4,8,16」と１から
倍々に配列サイズを越える値≪２のべき乗の中で最大値≫を
算出します！
「i/=2;s=i/2;」は、探索する初期値として先ほど算出した
最大値の半分、そしてさらに刻み（ステップ）数をその半分
で算出！
「for(;s>0;s/=2){・・外側ループ中身・・}」は、ｆｏｒ
ループ構文「for(;s>0;s/=2)」でループ条件「s>0」と刻み
（ステップ）数をループ後置「s/=2」と半々≪１／２ヅツ
減少≫させる事で刻み数が有効な間、外側ループ中身を処理
その外側ループ中身
「d=buf[i].x;」は、サーチ対象のＸ座標成分を取り出し
「if(d==x){return(i);}」と条件「d==x」仮引数「int x」
の目標値と一致しているのでこの時の添え字（インデックス
）を辺値とし返し関数終了！
「else if(d>x){i-=s;}」は、条件「d>x」で添え字を刻みで
減少！
「else{i+=s;while(i>=size){s/=2;i-=s;}}」は、「else」
詰り、条件「d<x」なので、この中で
「i+=s;」で添え字を刻みで増加！
「while(i>=size){s/=2;i-=s;}」は、Ｗｈｉｌｅループで
ループ条件「i>=size」は、添え字がサイズ以下の値の間
ループ中身「s/=2;i-=s;」で刻み数を半分にし、添え字を
刻みで減少！
外側ｆｏｒループが終了したら、
「return(i);」は、添え字（インデックス）を辺値とし
関数終了！インデックス
（４－１４－１２２）関数「int BinarySearchY(TypeXY buf[],
int size,int y) {・・・｝」
/********************************************************************************/
/***** ソート関連：TypeXYがＹ座標で昇順ソートしている時にＹ座標を探す *****/
/***** 関数返値：サーチしたIndex *****/
/********************************************************************************/
int CopyClear::BinarySearchY(
TypeXY buf[], // バッファー
int size, // バッファーサイズ
int y // 探査対象
){
int i; // 探査Index
int s; // 刻み
int d; // データ
for( i = 1; i < size; i *= 2 ){ // サイズの
; // 中心になるように
} // 探査Index
i /= 2; // 算出（２のベキ乗）
s = i / 2; // 刻み算出
for( ; s > 0; s /= 2 ){ // 以下を繰り返す
d = buf[i].y; // データを取り出し
if( d == y ){ // 探査終了したら
return( i ); // Indexを返す
}else if( d > y ){ // 大きければ
i -= s; // Index減少
}else{ // 小さければ
i += s; // Index増加
while( i >= size ){ // 最終Index Over時
s /= 2; // 刻み半分
i -= s; // Index減少
} //
} //
} //
return( i ); // 探査Indexを返す
}☆備考☆この関数はファイル「CopyClear130」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
（Ａ）関数「BinarySearchY()」の【関数名】
「Binary」は、英単語「Binary」で「広く２を表す」とか
「Search」は、英単語「英単語」で「探す・探索」です！
「BinarySearch」でコンピューターサイエンス的には、
用語「バイナリーサーチ・二分探索」としてソート済みの
配列に対して目的のデータを探す事を意味します！
「Y」は、Ｙ座標を示し、ココで使用する
仮引数「TypeXY buf[]」の「TypeXY型」、「座標組型」
≪解説『解説クラスＳｕｐｐｏｒｔ』の中で「（２）
構造体「struct構文で定義」したデータ構造」の更に
「（２－１）座標組用データ構造」で説明？！≫のＹ座標
に対して適応！
（Ｂ）関数「int BinarySearchY()」の【返値】
探索（サーチ）対象が発見された時の配列添え字（インデッ
クス）値を関数辺値とし返します！
（Ｃ）関数「BinarySearchY()」の【仮引数】
int CopyClear::BinarySearchY(
TypeXY buf[], // バッファー
int size, // バッファーサイズ
int y // 探査対象
){「TypeXY buf[],」は、探索（サーチ）対象の配列で
「TypeXY型」、「座標組型」≪解説『解説クラスＳｕｐｐｏ
ｒｔ』の中で「（２）構造体「struct構文で定義」した
データ構造」の更に「（２－１）座標組用データ構造」で
説明？！≫
「int size,」は、配列のサイズ
「int y」は、探索（サーチ）するＹ座標の値
（Ｄ）関数「BinarySearchY()」の【アルゴリズム】
){
int i; // 探査Index
int s; // 刻み
int d; // データ
for( i = 1; i < size; i *= 2 ){ // サイズの
; // 中心になるように
} // 探査Index
i /= 2; // 算出（２のベキ乗）
s = i / 2; // 刻み算出
for( ; s > 0; s /= 2 ){ // 以下を繰り返す
d = buf[i].y; // データを取り出し
if( d == y ){ // 探査終了したら
return( i ); // Indexを返す
}else if( d > y ){ // 大きければ
i -= s; // Index減少
}else{ // 小さければ
i += s; // Index増加
while( i >= size ){ // 最終Index Over時
s /= 2; // 刻み半分
i -= s; // Index減少
} //
} //
} //
return( i ); // 探査Indexを返す
}（Ｄ）ローカル変数
){
int i; // 探査Index
int s; // 刻み
int d; // データ「int i;」は、探査（サーチ）添え字（インデックス）
「int s;」は、探索ステップ刻み幅とし「step」からs名称
「int d;」は、比較データの一時、置き場
（Ｄ）アルゴリズムコード
for( i = 1; i < size; i *= 2 ){ // サイズの
; // 中心になるように
} // 探査Index
i /= 2; // 算出（２のベキ乗）
s = i / 2; // 刻み算出
for( ; s > 0; s /= 2 ){ // 以下を繰り返す
d = buf[i].y; // データを取り出し
if( d == y ){ // 探査終了したら
return( i ); // Indexを返す
}else if( d > y ){ // 大きければ
i -= s; // Index減少
}else{ // 小さければ
i += s; // Index増加
while( i >= size ){ // 最終Index Over時
s /= 2; // 刻み半分
i -= s; // Index減少
} //
} //
} //
return( i ); // 探査Indexを返す
}「for(i=1;i<size;i*=2){;}」は、「1,2,4,8,16」と１から
倍々に配列サイズを越える値≪２のべき乗の中で最大値≫を
算出します！
「i/=2;s=i/2;」は、探索する初期値として先ほど算出した
最大値の半分、そしてさらに刻み（ステップ）数をその半分
で算出！
「for(;s>0;s/=2){・・外側ループ中身・・}」は、ｆｏｒ
ループ構文「for(;s>0;s/=2)」でループ条件「s>0」と刻み
（ステップ）数をループ後置「s/=2」と半々≪１／２ヅツ
減少≫させる事で刻み数が有効な間、外側ループ中身を処理
その外側ループ中身
「d=buf[i].y;」は、サーチ対象のＹ座標成分を取り出し
「if(d==y){return(i);}」と条件「d==y」仮引数「int y」
の目標値と一致しているのでこの時の添え字（インデックス
）を辺値とし返し関数終了！
「else if(d>y){i-=s;}」は、条件「d>y」で添え字を刻みで
減少！
「else{i+=s;while(i>=size){s/=2;i-=s;}}」は、「else」
詰り、条件「d<y」なので、この中で
「i+=s;」で添え字を刻みで増加！
「while(i>=size){s/=2;i-=s;}」は、Ｗｈｉｌｅループで
ループ条件「i>=size」は、添え字がサイズ以下の値の間
ループ中身「s/=2;i-=s;」で刻み数を半分にし、添え字を
刻みで減少！
外側ｆｏｒループが終了したら、
「return(i);」は、添え字（インデックス）を辺値とし
関数終了！インデックス
（４－１４－１２３）関数「int BinarySearchX(TypeXYF buf[],
int size,double x) {・・・｝」
/********************************************************************************/
/***** ソート関連：TypeXYFがＸ座標で昇順ソートしている時にＸ座標を探す *****/
/***** 関数返値：サーチしたIndex *****/
/********************************************************************************/
int CopyClear::BinarySearchX(
TypeXYF buf[], // バッファー
int size, // バッファーサイズ
double x // 探査対象
){
int i; // 探査Index
int s; // 刻み
double d; // データ
for( i = 1; i < size; i *= 2 ){ // サイズの
; // 中心になるように
} // 探査Index
i /= 2; // 算出（２のベキ乗）
s = i / 2; // 刻み算出
for( ; s > 0; s /= 2 ){ // 以下を繰り返す
d = buf[i].x; // データを取り出し
if( d == x ){ // 探査終了したら
return( i ); // Indexを返す
}else if( d > x ){ // 大きければ
i -= s; // Index減少
}else{ // 小さければ
i += s; // Index増加
while( i >= size ){ // 最終Index Over時
s /= 2; // 刻み半分
i -= s; // Index減少
} //
} //
} //
return( i ); // 探査Indexを返す
}☆備考☆この関数はファイル「CopyClear130」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
（Ａ）関数「BinarySearchX()」の【関数名】
「Binary」は、英単語「Binary」で「広く２を表す」とか
「Search」は、英単語「英単語」で「探す・探索」です！
「BinarySearch」でコンピューターサイエンス的には、
用語「バイナリーサーチ・二分探索」としてソート済みの
配列に対して目的のデータを探す事を意味します！
「X」は、Ｘ座標を示し、ココで使用する
仮引数「TypeXYF buf[]」の「TypeXYF型」、「座標組型」
≪解説『解説クラスＳｕｐｐｏｒｔ』の中で「（２）
構造体「struct構文で定義」したデータ構造」の更に
「（２－１）座標組用データ構造」で説明？！≫のＸ座標
に対して適応！
（Ｂ）関数「int BinarySearchX()」の【返値】
探索（サーチ）対象が発見された時の配列添え字（インデッ
クス）値を関数辺値とし返します！
（Ｃ）関数「BinarySearchX()」の【仮引数】
int CopyClear::BinarySearchX(
TypeXYF buf[], // バッファー
int size, // バッファーサイズ
double x // 探査対象
){「TypeXYF buf[],」は、探索（サーチ）対象の配列で
「TypeXYF型」、「座標組型」≪解説『解説クラスＳｕｐｐｏ
ｒｔ』の中で「（２）構造体「struct構文で定義」した
データ構造」の更に「（２－１）座標組用データ構造」で
説明？！≫
「int size,」は、配列のサイズ
「double x」は、探索（サーチ）するＸ座標の値
（Ｄ）関数「BinarySearchX()」の【アルゴリズム】
){
int i; // 探査Index
int s; // 刻み
double d; // データ
for( i = 1; i < size; i *= 2 ){ // サイズの
; // 中心になるように
} // 探査Index
i /= 2; // 算出（２のベキ乗）
s = i / 2; // 刻み算出
for( ; s > 0; s /= 2 ){ // 以下を繰り返す
d = buf[i].x; // データを取り出し
if( d == x ){ // 探査終了したら
return( i ); // Indexを返す
}else if( d > x ){ // 大きければ
i -= s; // Index減少
}else{ // 小さければ
i += s; // Index増加
while( i >= size ){ // 最終Index Over時
s /= 2; // 刻み半分
i -= s; // Index減少
} //
} //
} //
return( i ); // 探査Indexを返す
}（Ｄ－１）ローカル変数
){
int i; // 探査Index
int s; // 刻み
double d; // データ「int i;」は、探査（サーチ）添え字（インデックス）
「int s;」は、探索ステップ刻み幅とし「step」からs名称
「double d;」は、比較データの一時、置き場
（Ｄ－２）アルゴリズムコード
for( i = 1; i < size; i *= 2 ){ // サイズの
; // 中心になるように
} // 探査Index
i /= 2; // 算出（２のベキ乗）
s = i / 2; // 刻み算出
for( ; s > 0; s /= 2 ){ // 以下を繰り返す
d = buf[i].x; // データを取り出し
if( d == x ){ // 探査終了したら
return( i ); // Indexを返す
}else if( d > x ){ // 大きければ
i -= s; // Index減少
}else{ // 小さければ
i += s; // Index増加
while( i >= size ){ // 最終Index Over時
s /= 2; // 刻み半分
i -= s; // Index減少
} //
} //
} //
return( i ); // 探査Indexを返す
}「for(i=1;i<size;i*=2){;}」は、「1,2,4,8,16」と１から
倍々に配列サイズを越える値≪２のべき乗の中で最大値≫を
算出します！
「i/=2;s=i/2;」は、探索する初期値として先ほど算出した
最大値の半分、そしてさらに刻み（ステップ）数をその半分
で算出！
「for(;s>0;s/=2){・・外側ループ中身・・}」は、ｆｏｒ
ループ構文「for(;s>0;s/=2)」でループ条件「s>0」と刻み
（ステップ）数をループ後置「s/=2」と半々≪１／２ヅツ
減少≫させる事で刻み数が有効な間、外側ループ中身を処理
その外側ループ中身
「d=buf[i].x;」は、サーチ対象のＸ座標成分を取り出し
「if(d==x){return(i);}」と条件「d==x」仮引数「double x」
の目標値と一致しているのでこの時の添え字（インデックス
）を辺値とし返し関数終了！
「else if(d>x){i-=s;}」は、条件「d>x」で添え字を刻みで
減少！
「else{i+=s;while(i>=size){s/=2;i-=s;}}」は、「else」
詰り、条件「d<x」なので、この中で
「i+=s;」で添え字を刻みで増加！
「while(i>=size){s/=2;i-=s;}」は、Ｗｈｉｌｅループで
ループ条件「i>=size」は、添え字がサイズ以下の値の間
ループ中身「s/=2;i-=s;」で刻み数を半分にし、添え字を
刻みで減少！
外側ｆｏｒループが終了したら、
「return(i);」は、添え字（インデックス）を辺値とし
関数終了！インデックス
（４－１４－１２４）関数「int BinarySearchY(TypeXYF buf[],
int size,double y) {・・・｝」
/********************************************************************************/
/***** ソート関連：TypeXYFがＹ座標で昇順ソートしている時にＹ座標を探す *****/
/***** 関数返値：サーチしたIndex *****/
/********************************************************************************/
int CopyClear::BinarySearchY(
TypeXYF buf[], // バッファー
int size, // バッファーサイズ
double y // 探査対象
){
int i; // 探査Index
int s; // 刻み
double d; // データ
for( i = 1; i < size; i *= 2 ){ // サイズの
; // 中心になるように
} // 探査Index
i /= 2; // 算出（２のベキ乗）
s = i / 2; // 刻み算出
for( ; s > 0; s /= 2 ){ // 以下を繰り返す
d = buf[i].y; // データを取り出し
if( d == y ){ // 探査終了したら
return( i ); // Indexを返す
}else if( d > y ){ // 大きければ
i -= s; // Index減少
}else{ // 小さければ
i += s; // Index増加
while( i >= size ){ // 最終Index Over時
s /= 2; // 刻み半分
i -= s; // Index減少
} //
} //
} //
return( i ); // 探査Indexを返す
}☆備考☆この関数はファイル「CopyClear130」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
（Ａ）関数「BinarySearchY()」の【関数名】
「Binary」は、英単語「Binary」で「広く２を表す」とか
「Search」は、英単語「英単語」で「探す・探索」です！
「BinarySearch」でコンピューターサイエンス的には、
用語「バイナリーサーチ・二分探索」としてソート済みの
配列に対して目的のデータを探す事を意味します！
「Y」は、Ｙ座標を示し、ココで使用する
仮引数「TypeXYF buf[]」の「TypeXYF型」、「座標組型」
≪解説『解説クラスＳｕｐｐｏｒｔ』の中で「（２）
構造体「struct構文で定義」したデータ構造」の更に
「（２－１）座標組用データ構造」で説明？！≫のＹ座標
に対して適応！
（Ｂ）関数「int BinarySearchY()」の【返値】
探索（サーチ）対象が発見された時の配列添え字（インデッ
クス）値を関数辺値とし返します！
（Ｃ）関数「BinarySearchY()」の【仮引数】
int CopyClear::BinarySearchY(
TypeXYF buf[], // バッファー
int size, // バッファーサイズ
double y // 探査対象
){「TypeXYF buf[],」は、探索（サーチ）対象の配列で
「TypeXYF型」、「座標組型」≪解説『解説クラスＳｕｐｐｏ
ｒｔ』の中で「（２）構造体「struct構文で定義」した
データ構造」の更に「（２－１）座標組用データ構造」で
説明？！≫
「int size,」は、配列のサイズ
「double y」は、探索（サーチ）するＹ座標の値
（Ｄ）関数「BinarySearchY()」の【アルゴリズム】
){
int i; // 探査Index
int s; // 刻み
double d; // データ
for( i = 1; i < size; i *= 2 ){ // サイズの
; // 中心になるように
} // 探査Index
i /= 2; // 算出（２のベキ乗）
s = i / 2; // 刻み算出
for( ; s > 0; s /= 2 ){ // 以下を繰り返す
d = buf[i].y; // データを取り出し
if( d == y ){ // 探査終了したら
return( i ); // Indexを返す
}else if( d > y ){ // 大きければ
i -= s; // Index減少
}else{ // 小さければ
i += s; // Index増加
while( i >= size ){ // 最終Index Over時
s /= 2; // 刻み半分
i -= s; // Index減少
} //
} //
} //
return( i ); // 探査Indexを返す
}（Ｄ－１）ローカル変数
){
int i; // 探査Index
int s; // 刻み
double d; // データ「int i;」は、探査（サーチ）添え字（インデックス）
「int s;」は、探索ステップ刻み幅とし「step」からs名称
「double d;」は、比較データの一時、置き場
（Ｄ－２）アルゴリズムコード
for( i = 1; i < size; i *= 2 ){ // サイズの
; // 中心になるように
} // 探査Index
i /= 2; // 算出（２のベキ乗）
s = i / 2; // 刻み算出
for( ; s > 0; s /= 2 ){ // 以下を繰り返す
d = buf[i].y; // データを取り出し
if( d == y ){ // 探査終了したら
return( i ); // Indexを返す
}else if( d > y ){ // 大きければ
i -= s; // Index減少
}else{ // 小さければ
i += s; // Index増加
while( i >= size ){ // 最終Index Over時
s /= 2; // 刻み半分
i -= s; // Index減少
} //
} //
} //
return( i ); // 探査Indexを返す
}「for(i=1;i<size;i*=2){;}」は、「1,2,4,8,16」と１から
倍々に配列サイズを越える値≪２のべき乗の中で最大値≫を
算出します！
「i/=2;s=i/2;」は、探索する初期値として先ほど算出した
最大値の半分、そしてさらに刻み（ステップ）数をその半分
で算出！
「for(;s>0;s/=2){・・外側ループ中身・・}」は、ｆｏｒ
ループ構文「for(;s>0;s/=2)」でループ条件「s>0」と刻み
（ステップ）数をループ後置「s/=2」と半々≪１／２ヅツ
減少≫させる事で刻み数が有効な間、外側ループ中身を処理
その外側ループ中身
「d=buf[i].y;」は、サーチ対象のＹ座標成分を取り出し
「if(d==y){return(i);}」と条件「d==y」仮引数「double y」
の目標値と一致しているのでこの時の添え字（インデックス
）を辺値とし返し関数終了！
「else if(d>y){i-=s;}」は、条件「d>y」で添え字を刻みで
減少！
「else{i+=s;while(i>=size){s/=2;i-=s;}}」は、「else」
詰り、条件「d<y」なので、この中で
「i+=s;」で添え字を刻みで増加！
「while(i>=size){s/=2;i-=s;}」は、Ｗｈｉｌｅループで
ループ条件「i>=size」は、添え字がサイズ以下の値の間
ループ中身「s/=2;i-=s;」で刻み数を半分にし、添え字を
刻みで減少！
外側ｆｏｒループが終了したら、
「return(i);」は、添え字（インデックス）を辺値とし
関数終了！インデックス
（４－１４－１２５）関数「int BinarySearchX(TypeXYD buf[],
int size,double x) {・・・｝」
/********************************************************************************/
/***** ソート関連：TypeXYFがＸ座標で昇順ソートしている時にＸ座標を探す *****/
/***** 関数返値：サーチしたIndex *****/
/********************************************************************************/
int CopyClear::BinarySearchX(
TypeXYD buf[], // バッファー
int size, // バッファーサイズ
double x // 探査対象
){
int i; // 探査Index
int s; // 刻み
double d; // データ
for( i = 1; i < size; i *= 2 ){ // サイズの
; // 中心になるように
} // 探査Index
i /= 2; // 算出（２のベキ乗）
s = i / 2; // 刻み算出
for( ; s > 0; s /= 2 ){ // 以下を繰り返す
d = buf[i].x; // データを取り出し
if( d == x ){ // 探査終了したら
return( i ); // Indexを返す
}else if( d > x ){ // 大きければ
i -= s; // Index減少
}else{ // 小さければ
i += s; // Index増加
while( i >= size ){ // 最終Index Over時
s /= 2; // 刻み半分
i -= s; // Index減少
} //
} //
} //
return( i ); // 探査Indexを返す
}☆備考☆この関数はファイル「CopyClear130」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
（Ａ）関数「BinarySearchX()」の【関数名】
「Binary」は、英単語「Binary」で「広く２を表す」とか
「Search」は、英単語「英単語」で「探す・探索」です！
「BinarySearch」でコンピューターサイエンス的には、
用語「バイナリーサーチ・二分探索」としてソート済みの
配列に対して目的のデータを探す事を意味します！
「X」は、Ｘ座標を示し、ココで使用する
仮引数「TypeXYD buf[]」の「TypeXYD型」、「座標組型」
≪解説『解説クラスＳｕｐｐｏｒｔ』の中で「（２）
構造体「struct構文で定義」したデータ構造」の更に
「（２－１）座標組用データ構造」で説明？！≫のＸ座標
に対して適応！
（Ｂ）関数「int BinarySearchX()」の【返値】
探索（サーチ）対象が発見された時の配列添え字（インデッ
クス）値を関数辺値とし返します！
（Ｃ）関数「BinarySearchX()」の【仮引数】
int CopyClear::BinarySearchX(
TypeXYD buf[], // バッファー
int size, // バッファーサイズ
double x // 探査対象
){「TypeXYD buf[],」は、探索（サーチ）対象の配列で
「TypeXYD型」、「座標組型」≪解説『解説クラスＳｕｐｐｏｒｔ』の中で「（２）構造体「struct構文で定義」した
データ構造」の更に「（２－１）座標組用データ構造」で
説明？！≫
「int size,」は、配列のサイズ
「double x」は、探索（サーチ）するＸ座標の値
（Ｄ）関数「BinarySearchX()」の【アルゴリズム】
){
int i; // 探査Index
int s; // 刻み
double d; // データ
for( i = 1; i < size; i *= 2 ){ // サイズの
; // 中心になるように
} // 探査Index
i /= 2; // 算出（２のベキ乗）
s = i / 2; // 刻み算出
for( ; s > 0; s /= 2 ){ // 以下を繰り返す
d = buf[i].x; // データを取り出し
if( d == x ){ // 探査終了したら
return( i ); // Indexを返す
}else if( d > x ){ // 大きければ
i -= s; // Index減少
}else{ // 小さければ
i += s; // Index増加
while( i >= size ){ // 最終Index Over時
s /= 2; // 刻み半分
i -= s; // Index減少
} //
} //
} //
return( i ); // 探査Indexを返す
}（Ｄ－１）ローカル変数
){
int i; // 探査Index
int s; // 刻み
double d; // データ「int i;」は、探査（サーチ）添え字（インデックス）
「int s;」は、探索ステップ刻み幅とし「step」からs名称
「double d;」は、比較データの一時、置き場
（Ｄ－２）アルゴリズムコード
for( i = 1; i < size; i *= 2 ){ // サイズの
; // 中心になるように
} // 探査Index
i /= 2; // 算出（２のベキ乗）
s = i / 2; // 刻み算出
for( ; s > 0; s /= 2 ){ // 以下を繰り返す
d = buf[i].x; // データを取り出し
if( d == x ){ // 探査終了したら
return( i ); // Indexを返す
}else if( d > x ){ // 大きければ
i -= s; // Index減少
}else{ // 小さければ
i += s; // Index増加
while( i >= size ){ // 最終Index Over時
s /= 2; // 刻み半分
i -= s; // Index減少
} //
} //
} //
return( i ); // 探査Indexを返す
}「for(i=1;i<size;i*=2){;}」は、「1,2,4,8,16」と１から
倍々に配列サイズを越える値≪２のべき乗の中で最大値≫を
算出します！
「i/=2;s=i/2;」は、探索する初期値として先ほど算出した
最大値の半分、そしてさらに刻み（ステップ）数をその半分
で算出！
「for(;s>0;s/=2){・・外側ループ中身・・}」は、ｆｏｒ
ループ構文「for(;s>0;s/=2)」でループ条件「s>0」と刻み
（ステップ）数をループ後置「s/=2」と半々≪１／２ヅツ
減少≫させる事で刻み数が有効な間、外側ループ中身を処理
その外側ループ中身
「d=buf[i].x;」は、サーチ対象のＸ座標成分を取り出し
「if(d==x){return(i);}」と条件「d==x」仮引数「double x」
の目標値と一致しているのでこの時の添え字（インデックス
）を辺値とし返し関数終了！
「else if(d>x){i-=s;}」は、条件「d>x」で添え字を刻みで
減少！
「else{i+=s;while(i>=size){s/=2;i-=s;}}」は、「else」
詰り、条件「d<x」なので、この中で
「i+=s;」で添え字を刻みで増加！
「while(i>=size){s/=2;i-=s;}」は、Ｗｈｉｌｅループで
ループ条件「i>=size」は、添え字がサイズ以下の値の間
ループ中身「s/=2;i-=s;」で刻み数を半分にし、添え字を
刻みで減少！
外側ｆｏｒループが終了したら、
「return(i);」は、添え字（インデックス）を辺値とし
関数終了！インデックス
（４－１４－１２６）関数「int BinarySearchY(TypeXYD buf[],
int size,double y) {・・・｝」
/********************************************************************************/
/***** ソート関連：TypeXYDがＹ座標で昇順ソートしている時にＹ座標を探す *****/
/***** 関数返値：サーチしたIndex *****/
/********************************************************************************/
int CopyClear::BinarySearchY(
TypeXYD buf[], // バッファー
int size, // バッファーサイズ
double y // 探査対象
){
int i; // 探査Index
int s; // 刻み
double d; // データ
for( i = 1; i < size; i *= 2 ){ // サイズの
; // 中心になるように
} // 探査Index
i /= 2; // 算出（２のベキ乗）
s = i / 2; // 刻み算出
for( ; s > 0; s /= 2 ){ // 以下を繰り返す
d = buf[i].y; // データを取り出し
if( d == y ){ // 探査終了したら
return( i ); // Indexを返す
}else if( d > y ){ // 大きければ
i -= s; // Index減少
}else{ // 小さければ
i += s; // Index増加
while( i >= size ){ // 最終Index Over時
s /= 2; // 刻み半分
i -= s; // Index減少
} //
} //
} //
return( i ); // 探査Indexを返す
}☆備考☆この関数はファイル「CopyClear130」に存在！
★注意★この関数は「public:」属性ですのでライブラリの
外から使用可能です！
（Ａ）関数「BinarySearchY()」の【関数名】
「Binary」は、英単語「Binary」で「広く２を表す」とか
「Search」は、英単語「Search」で「探す・探索」です！
「BinarySearch」でコンピューターサイエンス的には、
用語「バイナリーサーチ・二分探索」としてソート済みの
配列に対して目的のデータを探す事を意味します！
「Y」は、Ｙ座標を示し、ココで使用する
仮引数「TypeXYD buf[]」の「TypeXYD型」、「座標組型」
≪解説『解説クラスＳｕｐｐｏｒｔ』の中で「（２）
構造体「struct構文で定義」したデータ構造」の更に
「（２－１）座標組用データ構造」で説明？！≫のＹ座標
に対して適応！
（Ｂ）関数「int BinarySearchY()」の【返値】
探索（サーチ）対象が発見された時の配列添え字（インデッ
クス）値を関数辺値とし返します！
（Ｃ）関数「BinarySearchY()」の【仮引数】
int CopyClear::BinarySearchY(
TypeXYD buf[], // バッファー
int size, // バッファーサイズ
double y // 探査対象
){「TypeXYD buf[],」は、探索（サーチ）対象の配列で
「TypeXYD型」、「座標組型」≪解説『解説クラスＳｕｐｐｏｒｔ』の中で「（２）構造体「struct構文で定義」した
データ構造」の更に「（２－１）座標組用データ構造」で
説明？！≫
「int size,」は、配列のサイズ
「double y」は、探索（サーチ）するＹ座標の値
（Ｄ）関数「BinarySearchY()」の【アルゴリズム】
){
int i; // 探査Index
int s; // 刻み
double d; // データ
for( i = 1; i < size; i *= 2 ){ // サイズの
; // 中心になるように
} // 探査Index
i /= 2; // 算出（２のベキ乗）
s = i / 2; // 刻み算出
for( ; s > 0; s /= 2 ){ // 以下を繰り返す
d = buf[i].y; // データを取り出し
if( d == y ){ // 探査終了したら
return( i ); // Indexを返す
}else if( d > y ){ // 大きければ
i -= s; // Index減少
}else{ // 小さければ
i += s; // Index増加
while( i >= size ){ // 最終Index Over時
s /= 2; // 刻み半分
i -= s; // Index減少
} //
} //
} //
return( i ); // 探査Indexを返す
}（Ｄ－１）ローカル変数
){
int i; // 探査Index
int s; // 刻み
double d; // データ「int i;」は、探査（サーチ）添え字（インデックス）
「int s;」は、探索ステップ刻み幅とし「step」からs名称
「double d;」は、比較データの一時、置き場
（Ｄ－２）アルゴリズムコード
for( i = 1; i < size; i *= 2 ){ // サイズの
; // 中心になるように
} // 探査Index
i /= 2; // 算出（２のベキ乗）
s = i / 2; // 刻み算出
for( ; s > 0; s /= 2 ){ // 以下を繰り返す
d = buf[i].y; // データを取り出し
if( d == y ){ // 探査終了したら
return( i ); // Indexを返す
}else if( d > y ){ // 大きければ
i -= s; // Index減少
}else{ // 小さければ
i += s; // Index増加
while( i >= size ){ // 最終Index Over時
s /= 2; // 刻み半分
i -= s; // Index減少
} //
} //
} //
return( i ); // 探査Indexを返す
}「for(i=1;i<size;i*=2){;}」は、「1,2,4,8,16」と１から
倍々に配列サイズを越える値≪２のべき乗の中で最大値≫を
算出します！
「i/=2;s=i/2;」は、探索する初期値として先ほど算出した
最大値の半分、そしてさらに刻み（ステップ）数をその半分
で算出！
「for(;s>0;s/=2){・・外側ループ中身・・}」は、ｆｏｒ
ループ構文「for(;s>0;s/=2)」でループ条件「s>0」と刻み
（ステップ）数をループ後置「s/=2」と半々≪１／２ヅツ
減少≫させる事で刻み数が有効な間、外側ループ中身を処理
その外側ループ中身
「d=buf[i].y;」は、サーチ対象のＹ座標成分を取り出し
「if(d==y){return(i);}」と条件「d==y」仮引数「double y」
の目標値と一致しているのでこの時の添え字（インデックス
）を辺値とし返し関数終了！
「else if(d>y){i-=s;}」は、条件「d>y」で添え字を刻みで
減少！
「else{i+=s;while(i>=size){s/=2;i-=s;}}」は、「else」
詰り、条件「d<y」なので、この中で
「i+=s;」で添え字を刻みで増加！
「while(i>=size){s/=2;i-=s;}」は、Ｗｈｉｌｅループで
ループ条件「i>=size」は、添え字がサイズ以下の値の間
ループ中身「s/=2;i-=s;」で刻み数を半分にし、添え字を
刻みで減少！
外側ｆｏｒループが終了したら、
「return(i);」は、添え字（インデックス）を辺値とし
関数終了！インデックス
本日（２月３）これでソート系「public:属性」の関数の
解説を終わりです！実際に作動するアルゴリズムは、
ソート系「private属性」の関数の中で解説します！
乞うご期待と記載して終わります！尚、この続きは、
正規化相関関数
☆４×４素専用関数☆系「public:属性」の関数の解説を
解説する解説解説『クラスＣｏｐｙＣｌｅａｒ（２３）』に
続きます！