解説クラスＳｕｐｐｏｒｔ続（２）

解説クラスＳｕｐｐｏｒｔ続（２）

２０２４年２月１６続講（初稿）

解説『解説クラスＳｕｐｐｏｒｔ続き』が大きく成り過ぎ
たのでその続きです！

（３－４－７５）関数「void up_movb2f(
BYTE*ps,float*pd,int l);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

void            Support::up_movb2f(
    BYTE        *ps,                            // 転送元へのポインタ
    float       *pd,                            // 転送先へのポインタ
    int         l                               // 転送する数量
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = *ps++;                      // 転送する
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = *ps++;                          // 転送する
    }                                           //
}

（３－４－７５－Ａ）関数名「up_movb2f」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」と
しての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ移動
と言う依り、コピー動作を行う物です！
一番使用頻度が多いと考えられたので省略して短く表現し
ました！
「b」は、型名「BYTE」の略です？！
勿論、「unsigned　char」１バイト単位として扱います！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換の「から」です！
「f」は、型名「float」の略です？！
勿論、単精度浮動小数点４バイト単位として扱います！

（３－４－７５－Ｂ）関数「up_movb2f()」の【仮引数】説明

void            Support::up_movb2f(
    BYTE        *ps,                            // 転送元へのポインタ
    float       *pd,                            // 転送先へのポインタ
    int         l                               // 転送する数量
){

「BYTE*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「float*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み領域
を示す）ポインタです！
「int l」は、転送（書き込む）長さです！

（３－４－７５－Ｃ）関数「up_movb2f()」の
【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = *ps++;                      // 転送する
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = *ps++;                          // 転送する
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが
８以上在る場合は、先ず、「l-=8;」とコレから処理する
長さ８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd++ = *ps++;」と１単位処理を
８個連続で記述して８回分のループの代わりに高速に動作
させて居ます！
関数「up_fill()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、
理解して頂けると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正で
す！
「while(--l>=0){*pd++=*ps++;}」は、本来、
この関数「up_movb2f()」の基本的な処理部分と判る
でしょう？！コレを処理長さ「l」が十分大きい時に
小細工を施した事が判るでしょう！

（３－４－７６）関数「void up_movb2d(
BYTE*ps,double*pd,int l);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

void            Support::up_movb2d(
    BYTE        *ps,                            // 転送元へのポインタ
    double      *pd,                            // 転送先へのポインタ
    int         l                               // 転送する数量
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = *ps++;                      // 転送する
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = *ps++;                          // 転送する
    }                                           //
}

（３－４－７６－Ａ）関数名「up_movb2d」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の関数
をグローバル大域関数として「高速動作用汎用関数」として
の接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ
移動と言う依り、コピー動作を行う物です！
一番使用頻度が多いと考えられたので省略して短く表現
しました！
「b」は、型名「BYTE」の略です？！
勿論、「unsigned　char」１バイト単位として扱います！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換の「から」です！
「d」は、型名「double」の略です？！
勿論、倍精度浮動小数点８バイト単位として扱います！

（３－４－７６－Ｂ）関数「up_movb2d()」の【仮引数】説明

void            Support::up_movb2d(
    BYTE        *ps,                            // 転送元へのポインタ
    double      *pd,                            // 転送先へのポインタ
    int         l                               // 転送する数量
){

「BYTE*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「double*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み
領域を示す）ポインタです！
「int l」は、転送（書き込む）長さです！

（３－４－７６－Ｃ）関数「up_movb2d()」の
【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = *ps++;                      // 転送する
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = *ps++;                          // 転送する
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが８以上
在る場合は、先ず、「l-=8;」とコレから処理する長さ
８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd++ = *ps++;」と１単位処理を
８個連続で記述して８回分のループの代わりに高速に動作
させて居ます！
関数「up_fill()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して頂
けると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正
です！
「while(--l>=0){*pd++=*ps++;}」は、本来、
この関数「up_movb2d()」の基本的な処理部分と判る
でしょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した
事が判るでしょう！

（３－４－７７）関数「void up_movs2f(
short*ps,float*pd,int l);」の説明

この関数の本体は、ファイル「Support.cpp」に格納されて
居て次の様に

void            Support::up_movs2f(
    short       *ps,                            // 転送元へのポインタ
    float       *pd,                            // 転送先へのポインタ
    int         l                               // 転送する数量
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = *ps++;                      // 転送する
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = *ps++;                          // 転送する
    }                                           //
}

（３－４－７７－Ａ）関数名「up_movs2f」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ移動
と言う依り、コピー動作を行う物です！
一番使用頻度が多いと考えられたので省略して短く表現
しました！
「s」は、型名「short」の略です？！
勿論、２バイト単位として扱います！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換の「から」です！
「f」は、型名「float」の略です？！
勿論、単精度浮動小数点４バイト
単位として扱います！

（３－４－７７－Ｂ）関数「up_movs2f()」の【仮引数】説明

void            Support::up_movs2f(
    short       *ps,                            // 転送元へのポインタ
    float       *pd,                            // 転送先へのポインタ
    int         l                               // 転送する数量
){

「short*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「float*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み
領域を示す）ポインタです！
「int l」は、転送（書き込む）長さです！

（３－４－７７－Ｃ）関数「up_movs2f()」の
【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = *ps++;                      // 転送する
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = *ps++;                          // 転送する
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが８以上
在る場合は、先ず、「l-=8;」とコレから処理する長さ
８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd++ = *ps++;」と１単位処理を
８個連続で記述して８回分のループの代わりに高速に動作
させて居ます！
関数「up_fill()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して頂
けると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正で
す！
「while(--l>=0){*pd++=*ps++;}」は、本来、
この関数「up_movs2f()」の基本的な処理部分と判るで
しょう？！コレを処理長さ「l」が十分大きい時に小細工を
施した事が判るでしょう！

（３－４－７８）関数「void up_movs2d(
short*ps,double*pd,int l);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

void            Support::up_movs2d(
    short       *ps,                            // 転送元へのポインタ
    double      *pd,                            // 転送先へのポインタ
    int         l                               // 転送する数量
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = *ps++;                      // 転送する
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = *ps++;                          // 転送する
    }                                           //
}

（３－４－７８－Ａ）関数名「up_movs2d」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」と
しての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ移動
と言う依り、コピー動作を行う物です！
一番使用頻度が多いと考えられたので省略して短く表現
しました！
「s」は、型名「short」の略です？！勿論、２バイト単位と
して扱います！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換の「から」です！
「d」は、型名「double」の略です？！
勿論、倍精度浮動小数点８バイト単位として扱います！

（３－４－７８－Ｂ）関数「up_movs2d()」の【仮引数】説明

void            Support::up_movs2d(
    short       *ps,                            // 転送元へのポインタ
    double      *pd,                            // 転送先へのポインタ
    int         l                               // 転送する数量
){

「short*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「double*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み
領域を示す）ポインタです！
「int l」は、転送（書き込む）長さです！

（３－４－７８－Ｃ）関数「up_movs2d()」の
【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = *ps++;                      // 転送する
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = *ps++;                          // 転送する
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが
８以上在る場合は、先ず、「l-=8;」とコレから処理する
長さ８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd++ = *ps++;」と１単位処理を
８個連続で記述して８回分のループの代わりに高速に動作
させて居ます！
関数「up_fill()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して頂け
ると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正
です！
「while(--l>=0){*pd++=*ps++;}」は、本来、
この関数「up_movs2d()」の基本的な処理部分と判るで
しょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！

（３－４－７９）関数「void up_movl2f(
long*ps,float*pd,int l);」の説明

この関数の本体は、ファイル「Support.cpp」に格納されて居て次の様に

void            Support::up_movl2f(
    long        *ps,                            // 転送元へのポインタ
    float       *pd,                            // 転送先へのポインタ
    int         l                               // 転送する数量
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = (float)*ps++;               // 転送する
            *pd++ = (float)*ps++;               //
            *pd++ = (float)*ps++;               //
            *pd++ = (float)*ps++;               //
            *pd++ = (float)*ps++;               //
            *pd++ = (float)*ps++;               //
            *pd++ = (float)*ps++;               //
            *pd++ = (float)*ps++;               //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = (float)*ps++;                   // 転送する
    }                                           //
}

（３－４－７９－Ａ）関数名「up_movl2f」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」と
しての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ
移動と言う依り、コピー動作を行う物です！
一番使用頻度が多いと考えられたので省略して短く表現しま
した！
「l」は、型名「long」の略です？！
勿論、４バイト単位として扱います！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換の「から」です！
「f」は、型名「float」の略です？！
勿論、単精度浮動小数点４バイト単位として扱います！

（３－４－７９－Ｂ）関数「up_movl2f()」の【仮引数】説明

void            Support::up_movl2f(
    long        *ps,                            // 転送元へのポインタ
    float       *pd,                            // 転送先へのポインタ
    int         l                               // 転送する数量
){

「long*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「float*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み領域
を示す）ポインタです！
「int l」は、転送（書き込む）長さです！

（３－４－７９－Ｃ）関数「up_movl2f()」の
【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = (float)*ps++;               // 転送する
            *pd++ = (float)*ps++;               //
            *pd++ = (float)*ps++;               //
            *pd++ = (float)*ps++;               //
            *pd++ = (float)*ps++;               //
            *pd++ = (float)*ps++;               //
            *pd++ = (float)*ps++;               //
            *pd++ = (float)*ps++;               //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = (float)*ps++;                   // 転送する
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが
８以上在る場合は、先ず、「l-=8;」とコレから処理する
長さ８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd++ = (float)*ps++;」と１単位
処理を８個連続で記述して８回分のループの代わりに高速に
動作させて居ます！
関数「up_fill()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して頂け
ると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正
です！
「while(--l>=0){*pd++=(float)*ps++;}」は、本来、
この関数「up_movl2f()」の基本的な処理部分と判るで
しょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！
尚、「(float)」と明示的にキャスト演算を施す記述を
しているのは、コンパイラ処理系に依っては記載して無いと
自動的に「double型」に変換し無駄な機械コードが
生成されるからです！

（３－４－８０）関数「void up_movf2d(
long*ps,double*pd,int l);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

void            Support::up_movl2d(
    long        *ps,                            // 転送元へのポインタ
    double      *pd,                            // 転送先へのポインタ
    int         l                               // 転送する数量
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = *ps++;                      // 転送する
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = *ps++;                          // 転送する
    }                                           //
}

（３－４－８０－Ａ）関数名「up_movf2d」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ
移動と言う依り、コピー動作を行う物です！
一番使用頻度が多いと考えられたので省略して短く表現
しました！
「ｆ」は、型名「float」の略です？！
勿論、４バイト単位で単精度浮動小数点として扱います！
「2」は、発音が似ている英単語「to」の代りで「○○から□□」への変換
の「から」です！
「d」は、型名「double」の略です？！
勿論、倍精度浮動小数点８バイト単位として扱います！

（３－４－８０－Ｂ）関数「up_movf2d()」の【仮引数】説明

void            Support::up_movl2d(
    long        *ps,                            // 転送元へのポインタ
    double      *pd,                            // 転送先へのポインタ
    int         l                               // 転送する数量
){

「long*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「double*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み領域
を示す）ポインタです！
「int l」は、転送（書き込む）長さです！

（３－４－８０－Ｃ）関数「up_movf2d()」の
【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = *ps++;                      // 転送する
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = *ps++;                          // 転送する
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが
８以上在る場合は、先ず、「l-=8;」とコレから処理する
長さ８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd++ = *ps++;」と１単位処理を
８個連続で記述して８回分のループの代わりに高速に動作
させて居ます！
関数「up_fill()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して
頂けると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、
減算した値の補正です！
「while(--l>=0){*pd++=*ps++;}」は、本来、
この関数「up_movf2d()」の基本的な処理部分と判る
でしょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！

（３－４－８１）関数「void up_movd2f(
double*ps,float*pd,int l);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

void            Support::up_movd2f(
    double      *ps,                            // 転送元へのポインタ
    float       *pd,                            // 転送先へのポインタ
    int         l                               // 転送する数量
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = (float)*ps++;               // 転送する
            *pd++ = (float)*ps++;               //
            *pd++ = (float)*ps++;               //
            *pd++ = (float)*ps++;               //
            *pd++ = (float)*ps++;               //
            *pd++ = (float)*ps++;               //
            *pd++ = (float)*ps++;               //
            *pd++ = (float)*ps++;               //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = (float)*ps++;                   // 転送する
    }                                           //
}

（３－４－８１－Ａ）関数名「up_movd2f」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ移動
と言う依り、コピー動作を行う物です！
一番使用頻度が多いと考えられたので省略して短く表現
しました！
「d」は、型名「double」の略です？！
勿論、倍精度浮動小数点８バイト単位として扱います！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換の「から」です！
「f」は、型名「float」の略です？！
勿論、単精度浮動小数点４バイト単位として扱います！

（３－４－８１－Ｂ）関数「up_movd2f()」の【仮引数】説明

void            Support::up_movd2f(
    double      *ps,                            // 転送元へのポインタ
    float       *pd,                            // 転送先へのポインタ
    int         l                               // 転送する数量
){

「double*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「float*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み領域
を示す）ポインタです！
「int l」は、転送（書き込む）長さです！

（３－４－８１－Ｃ）関数「up_movd2f()」の
【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = (float)*ps++;               // 転送する
            *pd++ = (float)*ps++;               //
            *pd++ = (float)*ps++;               //
            *pd++ = (float)*ps++;               //
            *pd++ = (float)*ps++;               //
            *pd++ = (float)*ps++;               //
            *pd++ = (float)*ps++;               //
            *pd++ = (float)*ps++;               //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = (float)*ps++;                   // 転送する
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが
８以上在る場合は、先ず、「l-=8;」とコレから処理する
長さ８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd++ = (float)*ps++;」と
１単位処理を８個連続で記述して８回分のループの代わりに
高速に動作させて居ます！
関数「up_fill()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、
理解して頂けると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正
です！
「while(--l>=0){*pd++=(float)*ps++;}」は、本来、
この関数「up_movd2f()」の基本的な処理部分と判る
でしょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！
尚、「(float)」と明示的にキャスト演算を施す記述を
しているのは、コンパイラ処理系に依っては記載して
無いと自動的に「double型」に変換し無駄な機械コードが
生成されるからです！

（３－４－８２）関数「void up_movf2d(
float*ps,double*pd,int l);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

void            Support::up_movf2d(
    float       *ps,                            // 転送元へのポインタ
    double      *pd,                            // 転送先へのポインタ
    int         l                               // 転送する数量
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = *ps++;                      // 転送する
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = *ps++;                          // 転送する
    }                                           //
}

（３－４－８２－Ａ）関数名「up_movf2d」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ移動
と言う依り、コピー動作を行う物です！
一番使用頻度が多いと考えられたので省略して短く表現し
ました！
「f」は、型名「float」の略です？！
勿論、単精度浮動小数点４バイト単位として扱います！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換の「から」です！
「d」は、型名「double」の略です？！
勿論、倍精度浮動小数点８バイト単位として扱います！

（３－４－８２－Ｂ）関数「up_movf2d()」の【仮引数】説明

void            Support::up_movf2d(
    float       *ps,                            // 転送元へのポインタ
    double      *pd,                            // 転送先へのポインタ
    int         l                               // 転送する数量
){

「float*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「double*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み領域
を示す）ポインタです！
「int l」は、転送（書き込む）長さです！

（３－４－８２－Ｃ）関数「up_movf2d()」の
【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = *ps++;                      // 転送する
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
            *pd++ = *ps++;                      //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = *ps++;                          // 転送する
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが８以上
在る場合は、先ず、「l-=8;」とコレから処理する長さ
８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd++ = *ps++;」と１単位処理を
８個連続で記述して８回分のループの代わりに高速に動作
させて居ます！
関数「up_fill()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」
した事は、理解して頂けると思います！≫を実行し、
後置ループ判断「while((l-=8)>0);」は、勿論「l-=8」と
８減算し判断、この分岐ブロック最後の「l+=8;」は、
減算した値の補正です！
「while(--l>=0){*pd++=*ps++;}」は、本来、
この関数「up_movf2d()」の基本的な処理部分と判るで
しょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！

（３－４－８３）関数「void up_movf2b(
float*ps,BYTE*pd,int l);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

void            Support::up_movf2b(
    float       *ps,                            // 転送元へのポインタ
    BYTE        *pd,                            // 転送先へのポインタ
    int         l                               // 転送する数量
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = (int)*ps++;                 // 転送する
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = (int)*ps++;                     // 転送する
    }                                           //
}

（３－４－８３－Ａ）関数名「up_movf2b」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ移動
と言う依り、コピー動作を行う物です！
一番使用頻度が多いと考えられたので省略して短く表現
しました！
「f」は、型名「float」の略です？！
勿論、単精度浮動小数点４バイト単位として扱います！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換の「から」です！
「b」は、型名「BYTE」の略です？！
勿論、整数型≪unsigned char≫１バイト単位として扱い
ます！

（３－４－８３－Ｂ）関数「up_movf2b()」の【仮引数】説明

void            Support::up_movf2b(
    float       *ps,                            // 転送元へのポインタ
    BYTE        *pd,                            // 転送先へのポインタ
    int         l                               // 転送する数量
){

「float*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「BYTE*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み領域
を示す）ポインタです！
「int l」は、転送（書き込む）長さです！

（３－４－８３－Ｃ）関数「up_movf2b()」の
【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = (int)*ps++;                 // 転送する
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = (int)*ps++;                     // 転送する
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが
８以上在る場合は、先ず、「l-=8;」とコレから処理する
長さ８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd++=(int)*ps++;」と１単位処理を
８個連続で記述して８回分のループの代わりに高速に動作
させて居ます！
関数「up_fill()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して頂け
ると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正
です！
「while(--l>=0){*pd++=(int)*ps++;}」は、本来、
この関数「up_movf2b()」の基本的な処理部分と判るで
しょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！
尚、(int)とキャスト演算で明示的に整数型に変換して、
下位１バイト分がコピーされる事は理解して頂いて
ますね！

（３－４－８４）関数「void up_movf2s(
float*ps,short*pd,int l);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

void            Support::up_movf2s(
    float       *ps,                            // 転送元へのポインタ
    short       *pd,                            // 転送先へのポインタ
    int         l                               // 転送する数量
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = (int)*ps++;                 // 転送する
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = (int)*ps++;                     // 転送する
    }                                           //
}

（３－４－８４－Ａ）関数名「up_movf2s」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ
移動と言う依り、コピー動作を行う物です！
一番使用頻度が多いと考えられたので省略して短く表現
しました！
「f」は、型名「float」の略です？！
勿論、単精度浮動小数点４バイト単位として扱います！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換
の「から」です！
「s」は、型名「short」の略です？！
勿論、整数型≪short≫２バイト単位として扱います！

（３－４－８４－Ｂ）関数「up_movf2s()」の【仮引数】説明

void            Support::up_movf2s(
    float       *ps,                            // 転送元へのポインタ
    short       *pd,                            // 転送先へのポインタ
    int         l                               // 転送する数量
){

「float*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「short*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み領域
を示す）ポインタです！
「int l」は、転送（書き込む）長さです！

（３－４－８４－Ｃ）関数「up_movf2s()」の
【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = (int)*ps++;                 // 転送する
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = (int)*ps++;                     // 転送する
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが
８以上在る場合は、先ず、「l-=8;」とコレから処理する
長さ８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd++=(int)*ps++;」と１単位処理を
８個連続で記述して８回分のループの代わりに高速に動作
させて居ます！
関数「up_fill()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して
頂けると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正
です！
「while(--l>=0){*pd++=(int)*ps++;}」は、本来、
この関数「up_movf2s()」の基本的な処理部分と判る
でしょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！
尚、(int)とキャスト演算で明示的に整数型に変換して、
下位２バイト分がコピーされる事は理解して頂いてます
ね！

（３－４－８５）関数「void up_movf2l(
float*ps,long*pd,int l);」の説明

この関数の本体は、ファイル「Support.cpp」に
格納されて居て次の様に

void            Support::up_movf2l(
    float       *ps,                            // 転送元へのポインタ
    long        *pd,                            // 転送先へのポインタ
    int         l                               // 転送する数量
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = (int)*ps++;                 // 転送する
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = (int)*ps++;                     // 転送する
    }                                           //
}

（３－４－８５－Ａ）関数名「up_movf2l」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ
移動と言う依り、コピー動作を行う物です！
一番使用頻度が多いと考えられたので省略して短く表現
しました！
「f」は、型名「float」の略です？！
勿論、単精度浮動小数点４バイト単位として扱います！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換の「から」です！
「s」は、型名「long」の略です？！
勿論、整数型≪long≫４バイト単位として扱います！

（３－４－８５－Ｂ）関数「up_movf2l()」の【仮引数】説明

void            Support::up_movf2l(
    float       *ps,                            // 転送元へのポインタ
    long        *pd,                            // 転送先へのポインタ
    int         l                               // 転送する数量
){

「float*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「long*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み領域
を示す）ポインタです！
「int l」は、転送（書き込む）長さです！

（３－４－８５－Ｃ）関数「up_movf2l()」の
【アルゴリズム】説明

void            Support::up_movf2l(
    float       *ps,                            // 転送元へのポインタ
    long        *pd,                            // 転送先へのポインタ
    int         l                               // 転送する数量
){

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが
８以上在る場合は、先ず、「l-=8;」とコレから処理する
長さ８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd++=(int)*ps++;」と１単位処理を
８個連続で記述して８回分のループの代わりに高速に動作
させて居ます！
関数「up_fill()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して頂
けると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正
です！
「while(--l>=0){*pd++=(int)*ps++;}」は、本来、
この関数「up_movf2l()」の基本的な処理部分と判る
でしょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！

（３－４－８６）関数「void up_movd2b(
double*ps,BYTE*pd,int l);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

void            Support::up_movd2b(
    double*     ps,                             // 転送元へのポインタ
    BYTE*       pd,                             // 転送先へのポインタ
    int         l                               // 転送する数量
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = (int)*ps++;                 // 転送する
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = (int)*ps++;                     // 転送する
    }                                           //
}

（３－４－８６－Ａ）関数名「up_movd2b」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ
移動と言う依り、コピー動作を行う物です！一番使用頻度が
多いと考えられたので省略して短く表現しました！
「d」は、型名「double」の略です？！
勿論、倍精度浮動小数点８バイト単位として扱います！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換の「から」です！
「b」は、型名「BYTE」の略です？！
勿論、整数型≪unsigned char≫１バイト単位として扱いま
す！

（３－４－８６－Ｂ）関数「up_movd2b()」の【仮引数】説明

void            Support::up_movd2b(
    double*     ps,                             // 転送元へのポインタ
    BYTE*       pd,                             // 転送先へのポインタ
    int         l                               // 転送する数量
){

「double*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「BYTE*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み
領域を示す）ポインタです！
「int l」は、転送（書き込む）長さです！

（３－４－８６－Ｃ）関数「up_movd2b()」の
【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = (int)*ps++;                 // 転送する
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = (int)*ps++;                     // 転送する
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが８以上
在る場合は、先ず、「l-=8;」とコレから処理する長さ
８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd++=(int)*ps++;」と１単位処理を
８個連続で記述して８回分のループの代わりに高速に動作
させて居ます！
関数「up_fill()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して頂
けると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正
です！
「while(--l>=0){*pd++=(int)*ps++;}」は、本来、
この関数「up_movd2b()」の基本的な処理部分と判る
でしょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！
尚、(int)とキャスト演算で明示的に整数型に変換して、
下位１バイト分がコピーされる事は理解して頂いてます
ね！

（３－４－８７）関数「void up_movd2s(
double*ps,short*pd,int l);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

void            Support::up_movd2s(
    double*     ps,                             // 転送元へのポインタ
    short*      pd,                             // 転送先へのポインタ
    int         l                               // 転送する数量
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = (int)*ps++;                 // 転送する
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = (int)*ps++;                     // 転送する
    }                                           //
}

（３－４－８７－Ａ）関数名「up_movd2s」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ
移動と言う依り、コピー動作を行う物です！
一番使用頻度が多いと考えられたので省略して短く表現
しました！
「d」は、型名「double」の略です？！
勿論、倍精度浮動小数点８バイト単位として扱います！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換の「から」です！
「s」は、型名「short」の略です？！
勿論、整数型≪short≫２バイト単位として扱います！

（３－４－８７－Ｂ）関数「up_movd2s()」の【仮引数】説明

void            Support::up_movd2s(
    double*     ps,                             // 転送元へのポインタ
    short*      pd,                             // 転送先へのポインタ
    int         l                               // 転送する数量
){

「double*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「short*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み
領域を示す）ポインタです！
「int l」は、転送（書き込む）長さです！

（３－４－８７－Ｃ）関数「up_movd2s()」の
【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = (int)*ps++;                 // 転送する
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = (int)*ps++;                     // 転送する
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが８以上
在る場合は、先ず、「l-=8;」とコレから処理する長さ
８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd++=(int)*ps++;」と１単位処理を
８個連続で記述して８回分のループの代わりに高速に動作
させて居ます！
関数「up_fill()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して頂
けると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正
です！
「while(--l>=0){*pd++=(int)*ps++;}」は、本来、
この関数「up_movd2s()」の基本的な処理部分と判るで
しょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！
尚、(int)とキャスト演算で明示的に整数型に変換して、
下位２バイト分がコピーされる事は理解して頂いてますね！

（３－４－８８）関数「void up_movd2l(
double*ps,long*pd,int l);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

void            Support::up_movd2l(
    double*     ps,                             // 転送元へのポインタ
    long*       pd,                             // 転送先へのポインタ
    int         l                               // 転送する数量
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = (int)*ps++;                 // 転送する
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = (int)*ps++;                     // 転送する
    }                                           //
}

（３－４－８８－Ａ）関数名「up_movd2l」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ移動
と言う依り、コピー動作を行う物です！
一番使用頻度が多いと考えられたので省略して短く表現
しました！
「d」は、型名「double」の略です？！
勿論、倍精度浮動小数点８バイト単位として扱います！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換の「から」です！
「s」は、型名「long」の略です？！
勿論、整数型≪long≫４バイト単位として扱います！

（３－４－８８－Ｂ）関数「up_movd2l()」の【仮引数】説明

void            Support::up_movd2l(
    double*     ps,                             // 転送元へのポインタ
    long*       pd,                             // 転送先へのポインタ
    int         l                               // 転送する数量
){

「double*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「long*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み領域
を示す）ポインタです！
「int l」は、転送（書き込む）長さです！

（３－４－８８－Ｃ）関数「up_movd2l()」の
【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = (int)*ps++;                 // 転送する
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
            *pd++ = (int)*ps++;                 //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = (int)*ps++;                     // 転送する
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが８以上
在る場合は、先ず、「l-=8;」とコレから処理する長さ
８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd++=(int)*ps++;」と１単位処理を
８個連続で記述して８回分のループの代わりに高速に動作
させて居ます！
関数「up_fill()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して頂
けると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正
です！
「while(--l>=0){*pd++=(int)*ps++;}」は、本来、
この関数「up_movd2l()」の基本的な処理部分と判るで
しょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！

（３－４－８９）関数「void up_movd_inc(
double*ps,double*pd,int l,int incS,int incD);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

void        Support::up_movd_inc(
    double  *ps,                                // 転送元へのポインタ
    double  *pd,                                // 転送先へのポインタ
    int     l,                                  // 書き込む大きさ
    int     incS,                               // 増分：転送元 
    int     incD                                // 増分：転送先 
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = *ps;                          // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = *ps;                              // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

（３－４－８９－Ａ）関数名「up_movd_inc」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ移動
と言う依り、コピー動作を行う物です！
一番使用頻度が多いと考えられたので省略して短く表現
しました！
「d」は、型名「double」の略です？！
勿論、倍精度浮動小数点型の８バイト単位を意味します！
「inc」は、インクリメント 【ｉｎｃｒｅｍｅｎｔ】の
省略（ｉｎｃ）で任意の増加幅を設定出来る事が特徴です！

（３－４－８９－Ｂ）関数「up_movd_inc()」の【仮引数】説明

void        Support::up_movd_inc(
    double  *ps,                                // 転送元へのポインタ
    double  *pd,                                // 転送先へのポインタ
    int     l,                                  // 書き込む大きさ
    int     incS,                               // 増分：転送元 
    int     incD                                // 増分：転送先 
){

「double*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「double*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み領域
を示す）ポインタです！
「int l,」は、転送（書き込む）長さです！
「int incS,」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_fill()系」では「incS＝1」と
成って居ると同等です！
そして「S」は、「source」の略ですので元から先（宛先）
へコピーする元のデータポインタの一単位増加する増分
です！
「int incD 」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incS＝1」と
成って居ると同等です！
そして「D」は、「destination」の略ですので元から
先（宛先）へコピーする先のデータポインタの一単位増加
する増分です！

（３－４－８９－Ｃ）関数「up_movd_inc()」の
【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = *ps;                          // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = *ps;                              // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが8以上在
る場合は、先ず、「l-=8;」とコレから処理する長さ８分
処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd=*ps;ps+=incS;pd+=incD;」と
１単位処理を８個連続で記述して８回分のループの代わりに
高速に動作させて居ます！
関数「up_fill()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して
頂けると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正
です！
「while(--l>=0){*pd=*ps;ps+=incS;pd+=incD;}」は、
本来、この関数「up_movd_inc()」の基本的な処理部分と
判るでしょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！
☆注意☆「ps+=incS;pd+=incD;」と
「source to destination」で別々にポインタを増加させて
いる事に注目して下さい！
この関数は、画像メモリを縦方向に処理する事を考えて居
ますので「source」側の増加幅と「destination」側の
増加幅が異なっても動作出来ます！

★備考★
解説『解説クラスＴｙｐｅＡｒｒａｙ』でも記載したが、
ｎｏｔｅエディタの変な特性でコピペした文章の半角「*」
が消されたり、空白「 」が消される事が多々あります！
注意して手作業で修正している筈ですが、必ず、ｃｏｄｅ
機能で表示して居る物を正しいとして確認して下さい

取り敢えず、今日（２月１６）の講義はココまで
お疲れ様です！マダ続きが有りますが、それは後日！！

２０２４年２月１７続講

（３－４－９０）関数「void up_movf_inc(
float*ps,float*pd,int l,int incS,int incD);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

void        Support::up_movf_inc(
    float   *ps,                                // 転送元へのポインタ
    float   *pd,                                // 転送先へのポインタ
    int     l,                                  // 書き込む大きさ
    int     incS,                               // 増分：転送元 
    int     incD                                // 増分：転送先 
){
    up_movl_inc( (long*)ps, (long*)pd,          // ３２Bit単位転送
                            l, incS, incD );    //
}

（３－４－９０－Ａ）関数名「up_movf_inc」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ移動
と言う依り、コピー動作を行う物です！
一番使用頻度が多いと考えられたので省略して短く表現
しました！
「f」は、型名「float」の略です？！
勿論、単精度浮動小数点型の４バイト単位を意味します！
「inc」は、インクリメント 【ｉｎｃｒｅｍｅｎｔ】の
省略（ｉｎｃ）で任意の増加幅を設定出来る事が特徴です！

（３－４－９０－Ｂ）関数「up_movf_inc()」の【仮引数】説明

void        Support::up_movf_inc(
    float   *ps,                                // 転送元へのポインタ
    float   *pd,                                // 転送先へのポインタ
    int     l,                                  // 書き込む大きさ
    int     incS,                               // 増分：転送元 
    int     incD                                // 増分：転送先 
){

「float*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「float*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み領域
を示す）ポインタです！
「int l,」は、転送（書き込む）長さです！
「int incS,」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_fill()系」では「incS＝1」と
成って居ると同等です！
そして「S」は、「source」の略ですので元から先（宛先）
へコピーする元のデータポインタの一単位増加する増分で
す！
「int incD 」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incS＝1」と
成って居ると同等です！
そして「D」は、「destination」の略ですので元から
先（宛先）へコピーする先のデータポインタの一単位増加
する増分です！

（３－４－９０－Ｃ）関数「up_movf_inc()」の
【アルゴリズム】説明

単に仮引数「float* ps,」仮引数「float* pd,」を型変換
キャストして「(long*)pd」・「(long*)pd」と置き換え
関数「up_movl_inc((long*)ps,(long*)pd,l,inc);」を実行
して居るだけです！
「long型」と「float型」が物理的に３２ビットだった
処理系で作成した為の物です！

単に仮引数「float ps,」仮引数「float pd,」を型変換
キャスト≪データ型では無くポインタ型を変換している事に
☆注意☆≫して「(long*)pd」・「(long*)pd」と置き換え
関数「up_movl((long*)ps,(long*)pd,l,inc);」を実行して
居るだけです！
「long型」と「float型」がメモリ上サイズで３２ビット
だった処理系で作成した為の物です！

（３－４－９１）関数「void up_movb2f_inc(
BYTE*ps,float*pd,int l,int incS,int incD);」の説明

この関数の本体は、ファイル「Support.cpp」に格納されて
居て次の様に

void            Support::up_movb2f_inc(
    BYTE        *ps,                            // 転送元へのポインタ
    float       *pd,                            // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = *ps;                          // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = *ps;                              // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

（３－４－９１－Ａ）関数名「up_movb2f_inc」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味す
る英単語です！
詰り「source to destination」と元から先（宛先）へ移動
と言う依り、コピー動作を行う物です！
一番使用頻度が多いと考えられたので省略して短く表現しま
した！
「b」は、型名「BYTE」の略です？！
勿論、「unsigned　char」１バイト単位として扱います！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換の「から」です！
「f」は、型名「float」の略です？！
勿論、単精度浮動小数点４バイト単位として扱います！
「inc」は、インクリメント 【ｉｎｃｒｅｍｅｎｔ】の
省略（ｉｎｃ）で任意の増加幅を設定出来る事が特徴です！

（３－４－９１－Ｂ）関数「up_movb2f_inc()」の
【仮引数】説明

void            Support::up_movb2f_inc(
    BYTE        *ps,                            // 転送元へのポインタ
    float       *pd,                            // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「BYTE*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「float*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み領域
を示す）ポインタです！
「int l,」は、転送（書き込む）長さです！
「int incS,」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_fill()系」では「incS＝1」と
成って居ると同等です！
そして「S」は、「source」の略ですので元から先（宛先）
へコピーする元のデータポインタの一単位増加する増分で
す！
「int incD 」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incD＝1」と
成って居ると同等です！
そして「D」は、「destination」の略ですので元から
先（宛先）へコピーする先のデータポインタの一単位増加
する増分です！

（３－４－９１－Ｃ）関数「up_movb2f_inc()」の
【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = *ps;                          // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = *ps;                              // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが
8以上在る場合は、先ず、「l-=8;」とコレから処理する長さ
８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd=*ps;ps+=incS;pd+=incD;」と
１単位処理を８個連続で記述して８回分のループの代わりに
高速に動作させて居ます！
関数「up_mov()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して頂け
ると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正で
す！
「while(--l>=0){*pd=*ps;ps+=incS;pd+=incD;}」は、
本来、この関数「up_movb2f_inc()」の基本的な処理部分と
判るでしょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！
☆注意☆「ps+=incS;pd+=incD;」と
「source to destination」で別々にポインタを増加させて
いる事に注目して下さい！
この関数は、画像メモリを縦方向に処理する事を考えて居ま
すので「source」側の増加幅と「destination」側の
増加幅が異なっても動作出来ます！

（３－４－９２）関数「void up_movb2d_inc(
BYTE*ps,double*pd,int l,int incS,int incD);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

void            Support::up_movb2d_inc(
    BYTE        *ps,                            // 転送元へのポインタ
    double      *pd,                            // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = *ps;                          // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = *ps;                              // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

（３－４－９２－Ａ）関数名「up_movb2d_inc」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」と
しての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味す
る英単語です！
詰り「source to destination」と元から先（宛先）へ移動
と言う依り、コピー動作を行う物です！一番使用頻度が多い
と考えられたので省略して短く表現しました！
「b」は、型名「BYTE」の略です？！
勿論、「unsigned　char」１バイト単位として扱います！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換の「から」です！
「d」は、型名「double」の略です？！
勿論、倍精度浮動小数点８バイト単位として扱います！
「inc」は、インクリメント 【ｉｎｃｒｅｍｅｎｔ】の
省略（ｉｎｃ）で任意の増加幅を設定出来る事が特徴です！

（３－４－９２－Ｂ）関数「up_movb2d_inc()」の
【仮引数】説明

void            Support::up_movb2d_inc(
    BYTE        *ps,                            // 転送元へのポインタ
    double      *pd,                            // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「BYTE*ps,」は、「source to destination」と元から
先（宛先）へコピーする元の
データポインタです！
「double*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み領域
を示す）ポインタです！
「int l,」は、転送（書き込む）長さです！
「int incS,」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incS＝1」と
成って居ると同等です！
そして「S」は、「source」の略ですので元から先（宛先）
へコピーする元のデータポインタの一単位増加する増分で
す！
「int incD 」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incD＝1」と
成って居ると同等です！
そして「D」は、「destination」の略ですので元から
先（宛先）へコピーする先のデータポインタの一単位増加
する増分です！

（３－４－９２－Ｃ）関数「up_movb2d_inc()」の
【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = *ps;                          // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = *ps;                              // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが
8以上在る場合は、先ず、「l-=8;」とコレから処理する長さ
８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd=*ps;ps+=incS;pd+=incD;」と
１単位処理を８個連続で記述して８回分のループの代わりに
高速に動作させて居ます！
関数「up_mov()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して頂け
ると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正で
す！
「while(--l>=0){*pd=*ps;ps+=incS;pd+=incD;}」は、
本来、この関数「up_movb2d_inc()」の基本的な処理部分と
判るでしょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！
☆注意☆「ps+=incS;pd+=incD;」と
「source to destination」で別々にポインタを増加させて
いる事に注目して下さい！
この関数は、画像メモリを縦方向に処理する事を考えて居ま
すので「source」側の増加幅と「destination」側の増加幅
が異なっても動作出来ます！

（３－４－９３）関数「void up_movs2f_inc(
short*ps,float*pd,int l,int incS,int incD);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

void            Support::up_movs2f_inc(
    short       *ps,                            // 転送元へのポインタ
    float       *pd,                            // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = *ps;                          // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = *ps;                              // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

（３－４－９３－Ａ）関数名「up_movs2f_inc」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」と
しての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ移動
と言う依り、コピー動作を行う物です！
一番使用頻度が多いと考えられたので省略して短く表現しま
した！
「s」は、型名「short」の略です？！
勿論、「short型」２バイト符号有り整数単位として扱いま
す！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換の「から」です！
「f」は、型名「float」の略です？！
勿論、単精度浮動小数点４バイト単位として扱います！
「inc」は、インクリメント 【ｉｎｃｒｅｍｅｎｔ】の
省略（ｉｎｃ）で任意の増加幅を設定出来る事が特徴です！

（３－４－９３－Ｂ）関数「up_movs2f_inc()」の
【仮引数】説明

void            Support::up_movs2f_inc(
    short       *ps,                            // 転送元へのポインタ
    float       *pd,                            // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「short*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「float*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み領域
を示す）ポインタです！
「int l,」は、転送（書き込む）長さです！
「int incS,」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_fill()系」では「incS＝1」と
成って居ると同等です！
そして「S」は、「source」の略ですので元から先（宛先）
へコピーする元のデータポインタの一単位増加する増分
です！
「int incD 」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incD＝1」と
成って居ると同等です！
そして「D」は、「destination」の略ですので元から
先（宛先）へコピーする先のデータポインタの一単位増加
する増分です！

（３－４－９３－Ｃ）関数「up_movs2f_inc()」の
【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = *ps;                          // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = *ps;                              // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが
8以上在る場合は、先ず、「l-=8;」とコレから処理する長さ
８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd=*ps;ps+=incS;pd+=incD;」と
１単位処理を８個連続で記述して８回分のループの代わりに
高速に動作させて居ます！
関数「up_mov()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して頂け
ると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正で
す！
「while(--l>=0){*pd=*ps;ps+=incS;pd+=incD;}」は、
本来、この関数「up_movs2f_inc()」の基本的な処理部分と
判るでしょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！
☆注意☆「ps+=incS;pd+=incD;」と
「source to destination」で別々にポインタを増加させて
いる事に注目して下さい！
この関数は、画像メモリを縦方向に処理する事を考えて居ま
すので「source」側の増加幅と「destination」側の増加幅
が異なっても動作出来ます！

（３－４－９４）関数「void up_movs2d_inc(
short*ps,double*pd,int l,int incS,int incD);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

void            Support::up_movs2d_inc(
    short       *ps,                            // 転送元へのポインタ
    double      *pd,                            // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = *ps;                          // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = *ps;                              // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

（３－４－９４－Ａ）関数名「up_movs2d_inc」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ移動
と言う依り、コピー動作を行う物です！
一番使用頻度が多いと考えられたので省略して短く表現し
ました！
「s」は、型名「short」の略です？！
勿論、「short型」２バイト符号有り整数単位として扱いま
す！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換の「から」です！
「d」は、型名「double」の略です？！
勿論、倍精度浮動小数点８バイト単位として扱います！
「inc」は、インクリメント 【ｉｎｃｒｅｍｅｎｔ】の
省略（ｉｎｃ）で任意の増加幅を設定出来る事が特徴です！

（３－４－９４－Ｂ）関数「up_movs2d_inc()」の
【仮引数】説明

void            Support::up_movs2d_inc(
    short       *ps,                            // 転送元へのポインタ
    double      *pd,                            // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「short*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「double*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み領域
を示す）ポインタです！
「int l,」は、転送（書き込む）長さです！
「int incS,」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incS＝1」と
成って居ると同等です！
そして「S」は、「source」の略ですので元から先（宛先）
へコピーする元のデータポインタの一単位増加する増分で
す！
「int incD 」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incD＝1」と
成って居ると同等です！
そして「D」は、「destination」の略ですので元から
先（宛先）へコピーする先のデータポインタの一単位増加
する増分です！

（３－４－９４－Ｃ）関数「up_movs2d_inc()」の
【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = *ps;                          // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = *ps;                              // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが
8以上在る場合は、先ず、「l-=8;」とコレから処理する長さ
８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd=*ps;ps+=incS;pd+=incD;」と
１単位処理を８個連続で記述して８回分のループの代わりに
高速に動作させて居ます！
関数「up_mov()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して頂け
ると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正
です！
「while(--l>=0){*pd=*ps;ps+=incS;pd+=incD;}」は、
本来、この関数「up_movs2d_inc()」の基本的な処理部分と
判るでしょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が判るでしょう！
☆注意☆「ps+=incS;pd+=incD;」と
「source to destination」で別々にポインタを増加させて
いる事に注目して下さい！
この関数は、画像メモリを縦方向に処理する事を考えて
居ますので「source」側の増加幅と「destination」側の
増加幅が異なっても動作出来ます！

（３－４－９５）関数「void up_movl2f_inc(
long*ps,float*pd,int l,int incS,int incD);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

void            Support::up_movl2f_inc(
    long        *ps,                            // 転送元へのポインタ
    float       *pd,                            // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = (float)*ps;                   // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (float)*ps;                       // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

（３－４－９５－Ａ）関数名「up_movl2f_inc」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ移動
と言う依り、コピー動作を行う物です！
一番使用頻度が多いと考えられたので省略して短く表現
しました！
「s」は、型名「long」の略です？！
勿論、「long型」４バイト符号有り整数単位として扱い
ます！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換の「から」です！
「f」は、型名「float」の略です？！
勿論、単精度浮動小数点４バイト単位として扱います！
「inc」は、インクリメント 【ｉｎｃｒｅｍｅｎｔ】の
省略（ｉｎｃ）で
任意の増加幅を設定出来る事が特徴です！

（３－４－９５－Ｂ）関数「up_movl2f_inc()」の
【仮引数】説明

void            Support::up_movl2f_inc(
    long        *ps,                            // 転送元へのポインタ
    float       *pd,                            // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「long*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「float*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み
領域を示す）ポインタです！
「int l,」は、転送（書き込む）長さです！
「int incS,」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_fill()系」では「incS＝1」と
成って居ると同等です！
そして「l」は、「source」の略ですので元から先（宛先）
へコピーする元のデータポインタの一単位増加する増分で
す！
「int incD 」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incD＝1」と
成って居ると同等です！
そして「D」は、「destination」の略ですので元から
先（宛先）へコピーする先のデータポインタの一単位増加
する増分です！

（３－４－９５－Ｃ）関数「up_movl2f_inc()」の
【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = (float)*ps;                   // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (float)*ps;                       // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが
8以上在る場合は、先ず、「l-=8;」とコレから処理する長さ
８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd=*ps;ps+=incS;pd+=incD;」と
１単位処理を８個連続で記述して８回分のループの代わりに
高速に動作させて居ます！
関数「up_mov()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して頂け
ると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正
です！
「while(--l>=0){*pd=*ps;ps+=incS;pd+=incD;}」は、
本来、この関数「up_movl2f_inc()」の基本的な処理部分と
判るでしょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！
☆注意☆「ps+=incS;pd+=incD;」と
「source to destination」で別々にポインタを増加させて
いる事に注目して下さい！
この関数は、画像メモリを縦方向に処理する事を考えて居ま
すので「source」側の増加幅と「destination」側の増加幅
が異なっても動作出来ます！

（３－４－９６）関数「void up_movl2d_inc(
long*ps,double*pd,int l,int incS,int incD);」の説明

この関数の本体は、ファイル「Support.cpp」に格納されて
居て次の様に

void            Support::up_movl2d_inc(
    long        *ps,                            // 転送元へのポインタ
    double      *pd,                            // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = *ps;                          // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = *ps;                              // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

（３－４－９６－Ａ）関数名「up_movl2d_inc」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」と
しての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ移動
と言う依り、コピー動作を行う物です！
一番使用頻度が多いと考えられたので省略して短く表現しま
した！
「l」は、型名「long」の略です？！
勿論、「long型」４バイト符号有り整数単位として扱いま
す！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換の「から」です！
「d」は、型名「double」の略です？！
勿論、倍精度浮動小数点８バイト単位として扱います！
「inc」は、インクリメント 【ｉｎｃｒｅｍｅｎｔ】の
省略（ｉｎｃ）で任意の増加幅を設定出来る事が特徴です！

（３－４－９６－Ｂ）関数「up_movl2d_inc()」の
【仮引数】説明

void            Support::up_movl2d_inc(
    long        *ps,                            // 転送元へのポインタ
    double      *pd,                            // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「long*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「double*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み領域
を示す）ポインタです！
「int l,」は、転送（書き込む）長さです！
「int incS,」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incS＝1」と
成って居ると同等です！
そして「S」は、「source」の略ですので元から先（宛先）
へコピーする元のデータポインタの一単位増加する増分で
す！
「int incD 」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incD＝1」と
成って居ると同等です！
そして「D」は、「destination」の略ですので元から
先（宛先）へコピーする先のデータポインタの一単位増加
する増分です！

（３－４－９６－Ｃ）関数「up_movl2d_inc()」の
【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = *ps;                          // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = *ps;                              // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが
8以上在る場合は、先ず、「l-=8;」とコレから処理する長さ
８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd=*ps;ps+=incS;pd+=incD;」と
１単位処理を８個連続で記述して８回分のループの代わりに
高速に動作させて居ます！
関数「up_mov()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して頂け
ると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正で
す！
「while(--l>=0){*pd=*ps;ps+=incS;pd+=incD;}」は、
本来、この関数「up_movl2d_inc()」の基本的な処理部分と
判るでしょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！
☆注意☆「ps+=incS;pd+=incD;」と
「source to destination」で別々にポインタを増加させて
いる事に注目して下さい！
この関数は、画像メモリを縦方向に処理する事を考えて居ま
すので「source」側の増加幅と「destination」側の増加幅
が異なっても動作出来ます！

（３－４－９７）関数「void up_movd2f_inc(
double*ps,float*pd,int l,int incS,int incD);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

void            Support::up_movd2f_inc(
    double      *ps,                            // 転送元へのポインタ
    float       *pd,                            // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = (float)*ps;                   // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (float)*ps;                       // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

（３－４－９７－Ａ）関数名「up_movd2f_inc」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」と
しての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味す
る英単語です！
詰り「source to destination」と元から先（宛先）へ移動
と言う依り、コピー動作を行う物です！
一番使用頻度が多いと考えられたので省略して短く表現しま
した！
「f」は、型名「floata」の略です？！
勿論、「double型」単精度浮動小数点８バイト単位として
扱います！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換の「から」です！
「f」は、型名「float」の略です？！
勿論、単精度浮動小数点４バイト単位として扱います！
「inc」は、インクリメント 【ｉｎｃｒｅｍｅｎｔ】の
省略（ｉｎｃ）で任意の増加幅を設定出来る事が特徴です！

（３－４－９７－Ｂ）関数「up_movd2f_inc()」の
【仮引数】説明

void            Support::up_movd2f_inc(
    double      *ps,                            // 転送元へのポインタ
    float       *pd,                            // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「double*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「float*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み領域
を示す）ポインタです！
「int l,」は、転送（書き込む）長さです！
「int incS,」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incS＝1」と
成って居ると同等です！
そして「S」は、「source」の略ですので元から先（宛先）
へコピーする元のデータポインタの一単位増加する増分で
す！
「int incD 」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incD＝1」と
成って居ると同等です！
そして「D」は、「destination」の略ですので元から
先（宛先）へコピーする先のデータポインタの一単位増加す
る増分です！

（３－４－９７－Ｃ）関数「up_movd2f_inc()」の
【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = (float)*ps;                   // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (float)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (float)*ps;                       // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが
8以上在る場合は、先ず、「l-=8;」とコレから処理する長さ
８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd=(float)*ps;ps+=incS;pd+=incD;
」と１単位処理を８個連続で記述して８回分のループの
代わりに高速に動作させて居ます！
関数「up_mov()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、
理解して頂けると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正
です！
「while(--l>=0){*pd=(float)*ps;ps+=incS;pd+=incD;}」
は、本来、この関数「up_movd2f_inc()」の基本的な処理
部分と判るでしょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！
☆注意☆「ps+=incS;pd+=incD;」と
「source to destination」で別々にポインタを増加させて
いる事に注目して下さい！
この関数は、画像メモリを縦方向に処理する事を考えて居ま
すので「source」側の増加幅と「destination」側の増加幅
が異なっても動作出来ます！
尚、「(float)」と明示的にキャスト演算を施す記述を
しているのは、コンパイラ処理系に依っては記載して無いと
自動的に「double型」に変換し無駄な機械コードが生成され
るからです！

（３－４－９８）関数「void up_movf2d_inc(
float*ps,double*pd,int l,int incS,int incD);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

void            Support::up_movf2d_inc(
    float       *ps,                            // 転送元へのポインタ
    double      *pd,                            // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = *ps;                          // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = *ps;                              // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

（３－４－９８－Ａ）関数名「up_movf2d_inc」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ移動
と言う依り、コピー動作を行う物です！
一番使用頻度が多いと考えられたので省略して短く表現
しました！
「f」は、型名「float」の略です？！
勿論、「float型」単精度浮動小数点４バイト単位として扱
います！「d」は、型名「double」の略です？！
勿論、「double型」倍精度浮動小数点８バイト単位として
扱います！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換の「から」です！
「inc」は、インクリメント 【ｉｎｃｒｅｍｅｎｔ】の
省略（ｉｎｃ）で任意の増加幅を設定出来る事が特徴です！

（３－４－９８－Ｂ）関数「up_movf2d_inc()」の
【仮引数】説明

void            Support::up_movf2d_inc(
    float       *ps,                            // 転送元へのポインタ
    double      *pd,                            // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「float*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「double*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み領域
を示す）ポインタです！
「int l,」は、転送（書き込む）長さです！
「int incS,」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incS＝1」と
成って居ると同等です！
そして「S」は、「source」の略ですので元から先（宛先）
へコピーする元のデータポインタの一単位増加する増分で
す！
「int incD 」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incD＝1」と
成って居ると同等です！
そして「D」は、「destination」の略ですので元から
先（宛先）へコピーする先のデータポインタの一単位増加
する増分です！

（３－４－９８－Ｃ）関数「up_movf2d_inc()」の
【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = *ps;                          // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = *ps;                              // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが
8以上在る場合は、先ず、「l-=8;」とコレから処理する長さ
８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd=*ps;ps+=incS;pd+=incD;」と
１単位処理を８個連続で記述して８回分のループの代わりに
高速に動作させて居ます！
関数「up_mov()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して頂け
ると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正で
す！
「while(--l>=0){*pd=*ps;ps+=incS;pd+=incD;}」は、
本来、この関数「up_movf2d_inc()」の基本的な処理部分と
判るでしょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！
☆注意☆「ps+=incS;pd+=incD;」と
「source to destination」で別々にポインタを増加させて
いる事に注目して下さい！
この関数は、画像メモリを縦方向に処理する事を考えて居ま
すので「source」側の増加幅と「destination」側の増加幅
が異なっても動作出来ます！

（３－４－９９）関数「void up_movf2b_inc(
float*ps,BYTE*pd,int l,int incS,int incD);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

void            Support::up_movf2b_inc(
    float       *ps,                            // 転送元へのポインタ
    BYTE        *pd,                            // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = (int)*ps;                     // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (int)*ps;                         // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

（３－４－９９－Ａ）関数名「up_movf2b_inc」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」と
しての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味す
る英単語です！
詰り「source to destination」と元から先（宛先）へ移動
と言う依り、コピー動作を行う物です！
一番使用頻度が多いと考えられたので省略して短く表現
しました！
「f」は、型名「float」の略です？！
勿論、単精度浮動小数点４バイト単位として扱います！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換の「から」です！
「b」は、型名「BYTE」の略です？！
勿論、整数型≪unsigned char≫１バイト単位として扱いま
す！
「inc」は、インクリメント 【ｉｎｃｒｅｍｅｎｔ】の
省略（ｉｎｃ）で任意の増加幅を設定出来る事が特徴です！

（３－４－９９－Ｂ）関数「up_movf2b_inc()」の
【仮引数】説明

void            Support::up_movf2b_inc(
    float       *ps,                            // 転送元へのポインタ
    BYTE        *pd,                            // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「float*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「BYTE*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み
領域を示す）ポインタです！
「int l,」は、転送（書き込む）長さです！
「int incS,」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incS＝1」と
成って居ると同等です！
そして「S」は、「source」の略ですので元から先（宛先）
へコピーする元のデータポインタの一単位増加する増分
です！
「int incD 」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incD＝1」と
成って居ると同等です！
そして「D」は、「destination」の略ですので元から
先（宛先）へコピーする先のデータポインタの一単位増加
する増分です！

（３－４－９９－Ｃ）関数「up_movf2b_inc()」の
【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = (int)*ps;                     // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (int)*ps;                         // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが8以上
在る場合は、先ず、「l-=8;」とコレから処理する長さ
８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd=(int)*ps;ps+=incS;pd+=incD;」
と１単位処理を８個連続で記述して８回分のループの代わり
に高速に動作させて居ます！
関数「up_mov()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して頂け
ると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正
です！
「while(--l>=0){*pd=(int)*ps;ps+=incS;pd+=incD;}」は、
本来、この関数「up_movf2b_inc()」の基本的な処理部分と
判るでしょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！
尚、(int)とキャスト演算で明示的に整数型に変換して、
下位１バイト分がコピーされる事は理解して頂いてますね！
☆注意☆「ps+=incS;pd+=incD;」と
「source to destination」で別々にポインタを増加させて
いる事に注目して下さい！この関数は、画像メモリを縦方向
に処理する事を考えて居ますので「source」側の増加幅と
「destination」側の増加幅が異なっても動作出来ます！

（３－４－１００）関数「void up_movf2s_inc(
float*ps,short*pd,int l,int incS,int incD);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

void            Support::up_movf2s_inc(
    float       *ps,                            // 転送元へのポインタ
    short       *pd,                            // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = (int)*ps;                     // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (int)*ps;                         // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

（３－４－１００－Ａ）関数名「up_movf2s_inc」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味す
る英単語です！
詰り「source to destination」と元から先（宛先）へ移動
と言う依り、コピー動作を行う物です！一番使用頻度が多い
と考えられたので省略して短く表現しました！
「f」は、型名「float」の略です？！
勿論、単精度浮動小数点４バイト単位として扱います！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換の「から」です！
「s」は、型名「short」の略です？！
勿論、「short型」２バイト符号有り整数単位として扱いま
す！
「inc」は、インクリメント 【ｉｎｃｒｅｍｅｎｔ】の
省略（ｉｎｃ）で任意の増加幅を設定出来る事が特徴です！

（３－４－１００－Ｂ）関数「up_movf2s_inc()」の【仮引数】説明

void            Support::up_movf2s_inc(
    float       *ps,                            // 転送元へのポインタ
    short       *pd,                            // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「float*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「short*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み領域
を示す）ポインタです！
「int l,」は、転送（書き込む）長さです！
「int incS,」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incS＝1」と
成って居ると同等です！
そして「S」は、「source」の略ですので元から先（宛先）
へコピーする元のデータポインタの一単位増加する増分
です！
「int incD 」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incD＝1」と
成って居ると同等です！
そして「D」は、「destination」の略ですので元から
先（宛先）へコピーする先のデータポインタの一単位増加
する増分です！

（３－４－１００－Ｃ）関数「up_movf2s_inc()」の【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = (int)*ps;                     // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (int)*ps;                         // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが
8以上在る場合は、先ず、「l-=8;」とコレから処理する長さ
８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd=(int)*ps;ps+=incS;pd+=incD;」
と１単位処理を８個連続で記述して８回分のループの代わり
に高速に動作させて居ます！
関数「up_mov()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して頂け
ると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正
です！
「while(--l>=0){*pd=(int)*ps;ps+=incS;pd+=incD;}」は、
本来、この関数「up_movf2s_inc()」の基本的な処理部分と
判るでしょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！
尚、(int)とキャスト演算で明示的に整数型に変換して、
下位２バイト分がコピーされる事は理解して頂いてますね！
☆注意☆「ps+=incS;pd+=incD;」と
「source to destination」で別々にポインタを増加させて
いる事に注目して下さい！
この関数は、画像メモリを縦方向に処理する事を考えて居ま
すので「source」側の増加幅と「destination」側の増加幅
が異なっても動作出来ます！

（３－４－１０１）関数「void up_movf2l_inc(
float*ps,long*pd,int l,int incS,int incD);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

void            Support::up_movf2l_inc(
    float       *ps,                            // 転送元へのポインタ
    long        *pd,                            // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = (int)*ps;                     // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (int)*ps;                         // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

（３－４－１０１－Ａ）関数名「up_movf2l_inc」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ移動
と言う依り、コピー動作を行う物です！
一番使用頻度が多いと考えられたので省略して短く表現しま
した！
「f」は、型名「float」の略です？！
勿論、単精度浮動小数点４バイト単位として扱います！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換の「から」です！
「l」は、型名「long」の略です？！
勿論、「long型」４バイト符号有り整数単位として扱い
ます！
「inc」は、インクリメント 【ｉｎｃｒｅｍｅｎｔ】の
省略（ｉｎｃ）で任意の増加幅を設定出来る事が特徴です！

（３－４－１０１－Ｂ）関数「up_movf2l_inc()」の
【仮引数】説明

void            Support::up_movf2l_inc(
    float       *ps,                            // 転送元へのポインタ
    long        *pd,                            // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「float*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「long*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み領域
を示す）ポインタです！
「int l,」は、転送（書き込む）長さです！
「int incS,」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incS＝1」と
成って居ると同等です！
そして「S」は、「source」の略ですので元から先（宛先）
へコピーする元のデータポインタの一単位増加する増分で
す！
「int incD 」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incD＝1」と
成って居ると同等です！
そして「D」は、「destination」の略ですので元から
先（宛先）へコピーする先のデータポインタの一単位増加
する増分です！

（３－４－１０１－Ｃ）関数「up_movf2l_inc()」の
【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = (int)*ps;                     // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (int)*ps;                         // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが
8以上在る場合は、先ず、「l-=8;」とコレから処理する長さ
８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd=(int)*ps;ps+=incS;pd+=incD;」
と１単位処理を８個連続で記述して８回分のループの代わり
に高速に動作させて居ます！
関数「up_mov()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して頂け
ると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正
です！
「while(--l>=0){*pd=(int)*ps;ps+=incS;pd+=incD;}」は、
本来、この関数「up_movf2l_inc()」の基本的な処理部分と
判るでしょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！
尚、(int)とキャスト演算で明示的に整数型に変換して、
下位４バイト分がコピーされる事は理解して頂いてますね！
☆注意☆「ps+=incS;pd+=incD;」と
「source to destination」で別々にポインタを増加させて
いる事に注目して下さい！
この関数は、画像メモリを縦方向に処理する事を考えて居ま
すので「source」側の増加幅と「destination」側の増加幅
が異なっても動作出来ます！

（３－４－１０２）関数「void up_movd2b_inc(
doubleps,BYTEpd,int l,int incS,int incD);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

void            Support::up_movd2b_inc(
    double*     ps,                             // 転送元へのポインタ
    BYTE*       pd,                             // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = (int)*ps;                     // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (int)*ps;                         // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

（３－４－１０２－Ａ）関数名「up_movd2b_inc」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ移動
と言う依り、コピー動作を行う物です！
一番使用頻度が多いと考えられたので省略して短く表現
しました！
「d」は、型名「double」の略です？！
勿論、「double型」倍精度浮動小数点８バイト単位として扱
います！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換の「から」です！
「b」は、型名「BYTE」の略です？！
勿論、整数型≪unsigned char≫
１バイト単位として扱います！
「inc」は、インクリメント 【ｉｎｃｒｅｍｅｎｔ】の
省略（ｉｎｃ）で任意の増加幅を設定出来る事が特徴です！

（３－４－１０２－Ｂ）関数「up_movd2b_inc()」の【仮引数】説明

void            Support::up_movd2b_inc(
    double*     ps,                             // 転送元へのポインタ
    BYTE*       pd,                             // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「double*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「BYTE*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み領域
を示す）ポインタです！
「int l,」は、転送（書き込む）長さです！
「int incS,」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incS＝1」と
成って居ると同等です！
そして「S」は、「source」の略ですので元から先（宛先）
へコピーする元のデータポインタの一単位増加する増分
です！
「int incD 」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incD＝1」と
成って居ると同等です！
そして「D」は、「destination」の略ですので元から
先（宛先）へコピーする先のデータポインタの一単位増加
する増分です！

（３－４－１０２－Ｃ）関数「up_movd2b_inc()」の【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = (int)*ps;                     // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (int)*ps;                         // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが
8以上在る場合は、先ず、「l-=8;」とコレから処理する長さ
８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd=(int)*ps;ps+=incS;pd+=incD;」
と１単位処理を８個連続で記述して８回分のループの代わり
に高速に動作させて居ます！
関数「up_mov()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して頂
けると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正
です！
「while(--l>=0){*pd=(int)*ps;ps+=incS;pd+=incD;}」は、
本来、
この関数「up_movd2b_inc()」の基本的な処理部分と判るで
しょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！
尚、(int)とキャスト演算で明示的に整数型に変換して、
下位１バイト分がコピーされる事は理解して頂いてますね！
☆注意☆「ps+=incS;pd+=incD;」と
「source to destination」で別々にポインタを増加させて
いる事に注目して下さい！
この関数は、画像メモリを縦方向に処理する事を考えて居ま
すので「source」側の増加幅と「destination」側の増加幅
が異なっても動作出来ます！

（３－４－１０３）関数「void up_movd2s_inc(
double*ps,short*pd,int l,int incS,int incD);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

void            Support::up_movd2s_inc(
    double*     ps,                             // 転送元へのポインタ
    short*      pd,                             // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = (int)*ps;                     // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (int)*ps;                         // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

（３－４－１０３－Ａ）関数名「up_movd2s_inc」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ移動
と言う依り、コピー動作を行う物です！
一番使用頻度が多いと考えられたので省略して短く表現
しました！
「d」は、型名「double」の略です？！
勿論、「double型」倍精度浮動小数点８バイト単位として
扱います！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換の「から」です！
「s」は、型名「short」の略です？！
勿論、「short型」２バイト符号有り整数単位として扱いま
す！
「inc」は、インクリメント 【ｉｎｃｒｅｍｅｎｔ】の
省略（ｉｎｃ）で任意の増加幅を設定出来る事が特徴です！

（３－４－１０３－Ｂ）関数「up_movd2s_inc()」の【仮引数】説明

void            Support::up_movd2s_inc(
    double*     ps,                             // 転送元へのポインタ
    short*      pd,                             // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「double*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「short*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み領域
を示す）ポインタです！
「int l,」は、転送（書き込む）長さです！
「int incS,」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incS＝1」と
成って居ると同等です！
そして「S」は、「source」の略ですので元から先（宛先）
へコピーする元のデータポインタの一単位増加する増分
です！
「int incD 」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incD＝1」と
成って居ると同等です！
そして「D」は、「destination」の略ですので元から
先（宛先）へコピーする先のデータポインタの一単位増加
する増分です！

（３－４－１０３－Ｃ）関数「up_movd2s_inc()」の【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = (int)*ps;                     // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (int)*ps;                         // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが
8以上在る場合は、先ず、「l-=8;」とコレから処理する長さ
８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd=(int)*ps;ps+=incS;pd+=incD;」
と１単位処理を８個連続で記述して８回分のループの代わり
に高速に動作させて居ます！
関数「up_mov()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して頂け
ると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正
です！
「while(--l>=0){*pd=(int)*ps;ps+=incS;pd+=incD;}」は、
本来、この関数「up_movd2s_inc()」の基本的な処理部分と
判るでしょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！
尚、(int)とキャスト演算で明示的に整数型に変換して、
下位２バイト分がコピーされる事は理解して頂いてますね！
☆注意☆「ps+=incS;pd+=incD;」と
「source to destination」で別々にポインタを増加させて
いる事に注目して下さい！
この関数は、画像メモリを縦方向に処理する事を考えて居ま
すので「source」側の増加幅と「destination」側の増加幅
が異なっても動作出来ます！

（３－４－１０４）関数「void up_movd2l_inc(
double*ps,long*pd,int l,int incS,int incD);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

void            Support::up_movd2l_inc(
    double*     ps,                             // 転送元へのポインタ
    long*       pd,                             // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = (int)*ps;                     // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (int)*ps;                         // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

（３－４－１０４－Ａ）関数名「up_movd2l_inc」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ移動
と言う依り、コピー動作を行う物です！一番使用頻度が多い
と考えられたので省略して短く表現しました！
「d」は、型名「double」の略です？！
勿論、「double型」倍精度浮動小数点８バイト単位として扱
います！
「2」は、発音が似ている英単語「to」の代りで
「○○から□□」への変換の「から」です！
「l」は、型名「long」の略です？！
勿論、「long型」４バイト符号有り整数単位として扱いま
す！
「inc」は、インクリメント 【ｉｎｃｒｅｍｅｎｔ】の
省略（ｉｎｃ）で任意の増加幅を設定出来る事が特徴です！

（３－４－１０４－Ｂ）関数「up_movd2l_inc()」の【仮引数】説明

void            Support::up_movd2l_inc(
    double*     ps,                             // 転送元へのポインタ
    long*       pd,                             // 転送先へのポインタ
    int         l,                              // 書き込む大きさ
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「double*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「long*pd,」は、「source to destination」と元から
先（宛先）へコピーする先（対応する実引数の書き込み領域
を示す）ポインタです！
「int l,」は、転送（書き込む）長さです！
「int incS,」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incS＝1」と
成って居ると同等です！
そして「S」は、「source」の略ですので元から先（宛先）
へコピーする元のデータポインタの一単位増加する増分
です！
「int incD 」は、この関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_mov()系」では「incD＝1」と
成って居ると同等です！
そして「D」は、「destination」の略ですので元から
先（宛先）へコピーする先のデータポインタの一単位増加
する増分です！

（３－４－１０４－Ｃ）関数「up_movd2l_inc()」の【アルゴリズム】説明

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = (int)*ps;                     // 転送する
            ps += incS;                         // （S:Ptrを増分進める）
            pd += incD;                         // （D:Ptrを増分進める）
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (int)*ps;                     //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (int)*ps;                         // 転送する
        ps += incS;                             // （S:Ptrを増分進める）
        pd += incD;                             // （D:Ptrを増分進める）
    }                                           //
}

「if(l>=8){l-=8;do{・・ループ中身・・}
while((l-=8)>0);」は、分岐条件「l>=8」と長さが
8以上在る場合は、先ず、「l-=8;」とコレから処理する長さ
８分処理するので一旦、８減算し
「do{・・ループ中身・・}while((l-=8)>0);」後置ループ
判断のループ中身≪「*pd=(int)*ps;ps+=incS;pd+=incD;」
と１単位処理を８個連続で記述して８回分のループの代わり
に高速に動作させて居ます！
関数「up_mov()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して頂け
ると思います！≫を実行し、後置ループ判断
「while((l-=8)>0);」は、勿論「l-=8」と８減算し判断、
この分岐ブロック最後の「l+=8;」は、減算した値の補正
です！
「while(--l>=0){*pd=(int)*ps;ps+=incS;pd+=incD;}」は、
本来、この関数「up_movd2l_inc()」の基本的な処理部分と
判るでしょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！
尚、(int)とキャスト演算で明示的に整数型に変換して、
下位４バイト分がコピーされる事は理解して頂いてますね！
☆注意☆「ps+=incS;pd+=incD;」と
「source to destination」で別々にポインタを増加させて
いる事に注目して下さい！この関数は、画像メモリを縦方向
に処理する事を考えて居ますので「source」側の増加幅と
「destination」側の増加幅が異なっても動作出来ます！

★備考★
解説『解説クラスＴｙｐｅＡｒｒａｙ』でも記載したが、
ｎｏｔｅエディタの変な特性でコピペした文章の半角「*」
が消されたり、空白「 」が消される事が多々あります！
注意して手作業で修正している筈ですが、必ず、ｃｏｄｅ
機能で表示して居る物を正しいとして確認して下さい

取り敢えず、今日（２月１７）の講義はココまで
お疲れ様です！マダ続きが有りますが、それは後日！！

２０２４年２月１８続講

（３－４－１０５）関数「int MinLine(
BYTE*line,int size);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

int             Support::MinLine(
    BYTE*       line,                               // データPtr
    int         size                                // サイズ
){
    BYTE        data;                               // データ
    BYTE        temp;                               // データ：比較用

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data > temp ){                          // 小さい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( (int)data );                            //
}

（３－４－１０５－Ａ）関数名「MinLine」の説明

「Min」は、英単語「minimum」の略≪最小≫を意味する
英単語です！
詰り「BYTE*line」で仮引数でポインタが示す実引数の
データの最小値を算出する関数です！
「line」は、一つながりの連続するデータを意味します！

（３－４－１０５－Ｂ）関数「MinLine()」の
【仮引数】説明

int             Support::MinLine(
    BYTE*       line,                               // データPtr
    int         size                                // サイズ
){

「BYTE*line,」は、連続するメモリ上データをポインタで
示す実引数のデータ列を示すポインタです！
「int size」は、計算するデータのサイズです！

（３－４－１０５－Ｃ）関数「MinLine()」の
【ローカル変数】説明

){
    BYTE        data;                               // データ
    BYTE        temp;                               // データ：比較用

「BYTE data;」は、結果の最小値
レジスターへ一時的な置き場所
「BYTE temp;」は、比較用データとして
仮引数「BYTE*line」から、一旦、ＣＰＵ内部の高速
レジスターへ一時的な置き場所

（３－４－１０５－Ｄ）関数「MinLine()」の
【アルゴリズム】説明

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data > temp ){                          // 小さい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( (int)data );                            //
}

「data = *line;」は、最初のデータを仮の最小値として
初期化！
「while(--size>=0) {・・ループ中身・・}」は、
ループ条件「(--size>=0)」で仮引数「int size」分ループ
中身を実行！
ループ中身「temp=*line++;if(data>temp){data=temp;}」と
「temp=*line++;」で一時的にＣＰＵ内部高速レジスターに
取り出し、「if(data>temp){data=temp;}」で最小値の依り
小さい方を「data」にセット！
最後に関数の値として「return((int)data);」とキャスト
演算で「int型」に変換するのは、ループの中身で
「BYTE型」同士の操作を行う事で無駄なキャスト
演算（型変換）が起こらない様に考慮した為です！

（３－４－１０６）関数「int MinLine(
short*line,int size);」の説明

この関数の本体は、ファイル「Support.cpp」に格納されて
居て次の様に

int             Support::MinLine(
    short*      line,                               // データPtr
    int         size                                // サイズ
){
    short       data;                               // データ
    short       temp;                               // データ：比較用

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data > temp ){                          // 小さい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( (int)data );                            //
}

（３－４－１０６－Ａ）関数名「MinLine」の説明

「Min」は、英単語「minimum」の略≪最小≫を意味する
英単語です！
詰り「short*line」で仮引数でポインタが示す実引数の
データの最小値を算出する関数です！
「line」は、一つながりの連続するデータを意味します！

（３－４－１０６－Ｂ）関数「MinLine()」の【仮引数】説明

int             Support::MinLine(
    short*      line,                               // データPtr
    int         size                                // サイズ
){

「short*line,」は、連続するメモリ上データをポインタで
示す実引数のデータ列を示すポインタです！
「int size」は、計算するデータのサイズです！

（３－４－１０６－Ｃ）関数「MinLine()」の
【ローカル変数】説明

){
    short       data;                               // データ
    short       temp;                               // データ：比較用

「short data;」は、結果の最小値レジスターへ一時的に
置き場所
「short temp;」は、比較用データとして
仮引数「short*line」から一旦、ＣＰＵ内部の高速
レジスターへ一時的な置き場所

（３－４－１０６－Ｄ）関数「MinLine()」の
【アルゴリズム】説明

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data > temp ){                          // 小さい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( (int)data );                            //
}

「data = *line;」は、最初のデータを仮の最小値として
初期化！
「while(--size>=0) {・・ループ中身・・}」は、
ループ条件「(--size>=0)」で仮引数「int size」分ループ
中身を実行ループ中身
「temp=*line++;if(data>temp){data=temp;}」と
「temp=*line++;」で一時的にＣＰＵ内部高速レジスターに
取り出し、
「if(data>temp){data=temp;}」で最小値の依り小さい方を
「data」にセット！
最後に関数の値として「return((int)data);」とキャスト
演算で「int型」に変換するのは、ループの中身で
「short型」同士の操作を行う事で無駄なキャスト
演算（型変換）が起こらない様に考慮した為です！

（３－４－１０７）関数「int MinLine(
int*line,int size);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

int             Support::MinLine(
    int*        line,                               // データPtr
    int         size                                // サイズ
){
    int         data;                               // データ
    int         temp;                               // データ：比較用

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data > temp ){                          // 小さい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( data );                                 //
}

（３－４－１０７－Ａ）関数名「MinLine」の説明

「Min」は、英単語「minimum」の略≪最小≫を意味する
英単語です！
詰り「int*line」で仮引数でポインタが示す実引数の
データの最小値を算出する関数です！
「line」は、一つながりの連続するデータを意味します！

（３－４－１０７－Ｂ）関数「MinLine()」の【仮引数】説明

int             Support::MinLine(
    int*        line,                               // データPtr
    int         size                                // サイズ
){

「int*line,」は、連続するメモリ上データをポインタで
示す実引数のデータ列を示すポインタです！
「int size」は、計算するデータのサイズです！

（３－４－１０７－Ｃ）関数「MinLine()」の
【ローカル変数】説明

){
    int         data;                               // データ
    int         temp;                               // データ：比較用

「int data;」は、結果の最小値をレジスターへ一時的に
置き場所！
「int temp;」は、比較用データとして仮引数「int*line」
から一旦、ＣＰＵ内部の高速レジスターへ一時的な置き場所

（３－４－１０７－Ｄ）関数「MinLine()」の
【アルゴリズム】説明

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data > temp ){                          // 小さい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( data );                                 //
}

「data = *line;」は、最初のデータを仮の最小値として
初期化！
「while(--size>=0) {・・ループ中身・・}」は、
ループ条件「(--size>=0)」で仮引数「int size」分ループ
中身を実行
ループ中身「temp=*line++;if(data>temp){data=temp;}」と
「temp=*line++;」で一時的にＣＰＵ内部高速レジスターに
取り出し、「if(data>temp){data=temp;}」で最小値の依り
小さい方を「data」にセット！
最後に関数の値として「return(data);」と関数の結果を
返します！

（３－４－１０８）関数「DWORD MinLine(
UWORD*line,int size);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

DWORD           Support::MinLine(
    UWORD*      line,                               // データPtr
    int         size                                // サイズ
){
    UWORD       data;                               // データ
    UWORD       temp;                               // データ：比較用

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data > temp ){                          // 小さい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( (DWORD)data );                          //
}

（３－４－１０８－Ａ）関数名「MinLine」の説明

「Min」は、英単語「minimum」の略≪最小≫を意味する
英単語です！
詰り「UWORD*line」で仮引数でポインタが示す実引数の
データの最小値を算出する関数です！
「line」は、一つながりの連続するデータを意味します！
序に関数の型「DWORD」は、「unsigned long」４バイト整数で符号無しです！

（３－４－１０８－Ｂ）関数「MinLine()」の【仮引数】説明

DWORD           Support::MinLine(
    UWORD*      line,                               // データPtr
    int         size                                // サイズ
){

「UWORD*line,」は、連続するメモリ上データをポインタで
示す実引数のデータ列を示すポインタです！

「int size」は、計算するデータのサイズです！
序に「UWORD」は、「unsigned short」２バイト整数
で符号無しです！

（３－４－１０８－Ｃ）関数「MinLine()」の
【ローカル変数】説明

){
    UWORD       data;                               // データ
    UWORD       temp;                               // データ：比較用

「UWORD data;」は、結果の最小値
レジスターへ一時的な置き場所
「UWORD temp;」は、比較用データとして
仮引数「UWORD*line」から一旦、ＣＰＵ内部の高速
レジスターへ一時的な置き場所

（３－４－１０８－Ｄ）関数「MinLine()」の
【アルゴリズム】説明

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data > temp ){                          // 小さい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( (DWORD)data );                          //
}

「data = *line;」は、最初のデータを仮の最小値として
初期化！
「while(--size>=0) {・・ループ中身・・}」は、
ループ条件「(--size>=0)」で仮引数「int size」分ループ
中身を実行
ループ中身「temp=*line++;if(data>temp){data=temp;}」と
「temp=*line++;」で一時的にＣＰＵ内部高速レジスターに
取り出し、「if(data>temp){data=temp;}」で最小値の依り
小さい方を「data」にセット！
最後に関数の値として「return((DWORD)data);」とキャスト
演算で「DWORD型」に変換するのは、ループの中身で
「UWORD型」同士の操作を行う事で無駄なキャスト
演算（型変換）が起こらない様に考慮した為です！

（３－４－１０９）関数「DWORD MinLine(
DWORD*line,int size);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

DWORD           Support::MinLine(
    DWORD*      line,                               // データPtr
    int         size                                // サイズ
){
    DWORD       data;                               // データ
    DWORD       temp;                               // データ：比較用

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data > temp ){                          // 小さい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( (DWORD)data );                          //
}

（３－４－１０９－Ａ）関数名「MinLine」の説明

「Min」は、英単語「minimum」の略≪最小≫を意味する
英単語です！
詰り「DWORD*line」で仮引数でポインタが示す実引数の
データの最小値を算出する関数です！
「line」は、一つながりの連続するデータを意味します！
序に関数の型「DWORD」は、「unsigned long」４バイト
整数で符号無しです！

（３－４－１０９－Ｂ）関数「MinLine()」の【仮引数】説明

DWORD           Support::MinLine(
    DWORD*      line,                               // データPtr
    int         size                                // サイズ
){

「DWORD*line,」は、連続するメモリ上データをポインタで
示す実引数のデータ列を示すポインタです！

「int size」は、計算するデータのサイズです！
序に「DWORD」は、「unsigned long」４バイト整数で
符号無しです！

（３－４－１０９－Ｃ）関数「MinLine()」の
【ローカル変数】説明

){
    DWORD       data;                               // データ
    DWORD       temp;                               // データ：比較用

「DWORD data;」は、結果の最小値レジスターへ一時的な
置き場所！
「DWORD temp;」は、比較用データとして
仮引数「DWORD*line」から一旦、ＣＰＵ内部の高速
レジスターへ一時的な置き場所！

（３－４－１０９－Ｄ）関数「MinLine()」の
【アルゴリズム】説明

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data > temp ){                          // 小さい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( (DWORD)data );                          //
}

「data = *line;」は、最初のデータを仮の最小値として
初期化！
「while(--size>=0) {・・ループ中身・・}」は、
ループ条件「(--size>=0)」で仮引数「int size」分ループ
中身を実行
ループ中身「temp=*line++;if(data>temp){data=temp;}」と
「temp=*line++;」で一時的にＣＰＵ内部高速レジスターに
取り出し、
「if(data>temp){data=temp;}」で最小値の依り小さい方を
「data」にセット！
最後に関数の値として「return((DWORD)data);」と
キャスト演算で「DWORD型」に変換するのは、ループの
中身で「DWORD型」同士の操作を行う事で無駄なキャスト
演算（型変換）が起こらない様に考慮した為です！

（３－４－１１０）関数「double MinLine(
float*line,int size);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

double          Support::MinLine(
    float*      line,                               // データPtr
    int         size                                // サイズ
){
    float       data;                               // データ
    float       temp;                               // データ：比較用

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data > temp ){                          // 小さい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( (double)data );                         //
}

（３－４－１１０－Ａ）関数名「MinLine」の説明

「Min」は、英単語「minimum」の略≪最小≫を意味する
英単語です！
詰り「float*line」で仮引数でポインタが示す実引数の
データの最小値を算出する関数です！
「line」は、一つながりの連続するデータを意味します！
序に関数の型「double」は、倍精度浮動小数点型で
Ｃ言語では式の中で実数型ならばデフォルトの型に成るから
です！

（３－４－１１０－Ｂ）関数「MinLine()」の【仮引数】説明

double          Support::MinLine(
    float*      line,                               // データPtr
    int         size                                // サイズ
){

「float*line,」は、連続するメモリ上データをポインタで
示す実引数のデータ列を示すポインタです！「float型」は
単精度浮動小数点４バイトサイズです！
「int size」は、計算するデータのサイズです！

（３－４－１１０－Ｃ）関数「MinLine()」の
【ローカル変数】説明

){
    float       data;                               // データ
    float       temp;                               // データ：比較用

「float data;」は、結果の最小値レジスターへ一時的な
置き場所！
「float temp;」は、比較用データとして
仮引数「float*line」から一旦、ＣＰＵ内部の高速
レジスターへ一時的な置き場所！

（３－４－１１０－Ｄ）関数「MinLine()」の
【アルゴリズム】説明

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data > temp ){                          // 小さい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( (double)data );                         //
}

「data = *line;」は、最初のデータを仮の最小値として
初期化！
「while(--size>=0) {・・ループ中身・・}」は、
ループ条件「(--size>=0)」で仮引数「int size」分ループ
中身を実行
ループ中身「temp=*line++;if(data>temp){data=temp;}」と
「temp=*line++;」で一時的にＣＰＵ内部高速レジスターに
取り出し、
「if(data>temp){data=temp;}」で最小値の依り小さい方を
「data」にセット！
最後に関数の値として「return((double)data);」と
キャスト演算で「double型」に変換するのは、ループの中身
で「float型」同士の操作を行う事で無駄なキャスト
演算（型変換）が起こらない様に考慮した為です！

（３－４－１１１）関数「double MinLine(
double*line,int size);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

double          Support::MinLine(
    double*     line,                               // データPtr
    int         size                                // サイズ
){
    double      data;                               // データ
    double      temp;                               // データ：比較用

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data > temp ){                          // 小さい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( data );                                 //
}

（３－４－１１１－Ａ）関数名「MinLine」の説明

「Min」は、英単語「minimum」の略≪最小≫を意味する
英単語です！
詰り「double*line」で仮引数でポインタが示す実引数の
データの最小値を算出する関数です！
「line」は、一つながりの連続するデータを意味します！
序に関数の型「double」は、倍精度浮動小数点型で
Ｃ言語では式の中で実数型ならばデフォルトの型に成るから
です！

（３－４－１１１－Ｂ）関数「MinLine()」の【仮引数】説明

double          Support::MinLine(
    double*     line,                               // データPtr
    int         size                                // サイズ
){

「double*line,」は、連続するメモリ上データをポインタで
示す実引数のデータ列を示すポインタです！
「double型」は倍精度浮動小数点型８バイトサイズです！
「int size」は、計算するデータのサイズです！

（３－４－１１１－Ｃ）関数「MinLine()」の
【ローカル変数】説明

){
    double      data;                               // データ
    double      temp;                               // データ：比較用

「double data;」は、結果の最小値レジスターへ一時的な
置き場所！
「double temp;」は、比較用データとして
仮引数「double*line」から一旦、ＣＰＵ内部の高速
レジスターへ一時的な置き場所！

（３－４－１１１－Ｄ）関数「MinLine()」の
【アルゴリズム】説明

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data > temp ){                          // 小さい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( data );                                 //
}

「data = *line;」は、最初のデータを仮の最小値として
初期化！
「while(--size>=0) {・・ループ中身・・}」は、
ループ条件「(--size>=0)」で仮引数「int size」分ループ
中身を実行
ループ中身「temp=*line++;if(data>temp){data=temp;}」と
「temp=*line++;」で一時的にＣＰＵ内部高速レジスターに
取り出し、「if(data>temp){data=temp;}」で最小値の依り
大きい方を「data」にセット！
最後に関数の値として「return(data);」で結果の値を返し
ます！

（３－４－１１２）関数「int MaxLine(
BYTE*line,int size);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

int             Support::MaxLine(
    BYTE*       line,                               // データPtr
    int         size                                // サイズ
){
    BYTE        data;                               // データ
    BYTE        temp;                               // データ：比較用

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data < temp ){                          // 大きい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( (int)data );                            //
}

（３－４－１１２－Ａ）関数名「MaxLine」の説明

「Max」は、英単語「maximum」の略≪最大≫を意味する
英単語です！
詰り「BYTE*line」で仮引数でポインタが示す実引数の
データの最大値を算出する関数です！
「line」は、一つながりの連続するデータを意味します！

（３－４－１１２－Ｂ）関数「MaxLine()」の【仮引数】説明

int             Support::MaxLine(
    BYTE*       line,                               // データPtr
    int         size                                // サイズ
){

「BYTE*line,」は、連続するメモリ上データをポインタで
示す実引数のデータ列を示すポインタです！
「int size」は、計算するデータのサイズです！

（３－４－１１２－Ｃ）関数「MaxLine()」の
【ローカル変数】説明

){
    BYTE        data;                               // データ
    BYTE        temp;                               // データ：比較用

「BYTE data;」は、結果の最大値
レジスターへ一時的な置き場所
「BYTE temp;」は、比較用データとして
仮引数「BYTE*line」から一旦、ＣＰＵ内部の高速
レジスターへ一時的な置き場所！

（３－４－１１２－Ｄ）関数「MaxLine()」の
【アルゴリズム】説明

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data < temp ){                          // 大きい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( (int)data );                            //
}

「data = *line;」は、最初のデータを仮の最大値として
初期化！
「while(--size>=0) {・・ループ中身・・}」は、
ループ条件「(--size>=0)」で仮引数「int size」分ループ
中身を実行
ループ中身「temp=*line++;if(data<temp){data=temp;}」と
「temp=*line++;」で一時的にＣＰＵ内部高速レジスターに
取り出し、「if(data<temp){data=temp;}」で最大値の依り
大きい方を「data」にセット！
最後に関数の値として「return((int)data);」とキャスト
演算で「int型」に変換するのは、ループの中身で
「BYTE型」同士の操作を行う事で無駄なキャスト
演算（型変換）が起こらない様に考慮した為です！

（３－４－１１３）関数「int MaxLine(
short*line,int size);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

int             Support::MaxLine(
    short*      line,                               // データPtr
    int         size                                // サイズ
){
    short       data;                               // データ
    short       temp;                               // データ：比較用

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data < temp ){                          // 大きい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( (int)data );                            //
}

（３－４－１１３－Ａ）関数名「MaxLine」の説明

「Max」は、英単語「maximum」の略≪最大≫を意味する
英単語です！
詰り「short*line」で仮引数でポインタが示す実引数の
データの最大値を算出する関数です！
「line」は、一つながりの連続するデータを意味します！

（３－４－１１３－Ｂ）関数「MaxLine()」の【仮引数】説明

int             Support::MaxLine(
    short*      line,                               // データPtr
    int         size                                // サイズ
){

「short*line,」は、連続するメモリ上データをポインタで
示す実引数のデータ列を示すポインタです！
「int size」は、計算するデータのサイズです！

（３－４－１１３－Ｃ）関数「MaxLine()」の
【ローカル変数】説明

){
    short       data;                               // データ
    short       temp;                               // データ：比較用

「short data;」は、結果の最大値レジスターへ一時的な
置き場所！
「short temp;」は、比較用データとして
仮引数「short*line」から一旦、ＣＰＵ内部の高速
レジスターへ一時的な置き場所！

（３－４－１１３－Ｄ）関数「MaxLine()」の
【アルゴリズム】説明

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data < temp ){                          // 大きい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( (int)data );                            //
}

「data = *line;」は、最初のデータを仮の最大値として
初期化！
「while(--size>=0) {・・ループ中身・・}」は、
ループ条件「(--size>=0)」で仮引数「int size」分ループ
中身を実行！
ループ中身「temp=*line++;if(data<temp){data=temp;}」と
「temp=*line++;」で一時的にＣＰＵ内部高速レジスターに
取り出し、「if(data<temp){data=temp;}」で最大値の依り
大きい方を「data」にセット！
最後に関数の値として「return((int)data);」とキャスト
演算で「int型」に変換するのは、ループの中身で
「short型」同士の操作を行う事で無駄なキャスト
演算（型変換）が起こらない様に考慮した為です！

（３－４－１１４）関数「int MaxLine(
int*line,int size);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

int             Support::MaxLine(
    int*        line,                               // データPtr
    int         size                                // サイズ
){
    int         data;                               // データ
    int         temp;                               // データ：比較用

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data < temp ){                          // 大きい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( data );                                 //
}

（３－４－１１４－Ａ）関数名「MaxLine」の説明

「Max」は、英単語「maximum」の略≪最大≫を意味する
英単語です！
詰り「int*line」で仮引数でポインタが示す実引数の
データの最大値を
算出する関数です！
「line」は、一つながりの連続するデータを意味します！

（３－４－１１４－Ｂ）関数「MaxLine()」の【仮引数】説明

int             Support::MaxLine(
    int*        line,                               // データPtr
    int         size                                // サイズ
){

「int*line,」は、連続するメモリ上データをポインタで
示す実引数のデータ列を示すポインタです！
「int size」は、計算するデータのサイズです！

（３－４－１１４－Ｃ）関数「MaxLine()」の
【ローカル変数】説明

){
    int         data;                               // データ
    int         temp;                               // データ：比較用

「int data;」は、結果の最大値レジスターへ一時的な置き
場所！
「int temp;」は、比較用データとして
仮引数「int*line」から一旦、ＣＰＵ内部の高速
レジスターへ一時的な置き場所！

（３－４－１１４－Ｄ）関数「MaxLine()」の
【アルゴリズム】説明

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data < temp ){                          // 大きい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( data );                                 //
}

「data = *line;」は、最初のデータを仮の最大値として
初期化！
「while(--size>=0) {・・ループ中身・・}」は、
ループ条件「(--size>=0)」で仮引数「int size」分ループ
中身を実行！
ループ中身「temp=*line++;if(data<temp){data=temp;}」と
「temp=*line++;」で一時的にＣＰＵ内部高速レジスターに
取り出し、「if(data<temp){data=temp;}」で最大値の依り
大きい方を「data」にセット！
最後に関数の値として「return(data);」と関数の結果を返
します！

★備考★
解説『解説クラスＴｙｐｅＡｒｒａｙ』でも記載したが、
ｎｏｔｅエディタの変な特性でコピペした文章の半角「*」
が消されたり、空白「 」が消される事が多々あります！
注意して手作業で修正している筈ですが、必ず、ｃｏｄｅ
機能で表示して居る物を正しいとして確認して下さい

取り敢えず、今日（２月１８）の講義はココまで
お疲れ様です！マダ続きが有りますが、それは後日！！

２０２４年２月1９続講！！

（３－４－１１５）関数「DWORD MaxLine(
UWORD*line,int size);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

DWORD           Support::MaxLine(
    UWORD*      line,                               // データPtr
    int         size                                // サイズ
){
    UWORD       data;                               // データ
    UWORD       temp;                               // データ：比較用

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data < temp ){                          // 大きい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( (DWORD)data );                          //
}

（３－４－１１５－Ａ）関数名「MaxLine」の説明

「Max」は、英単語「maximum」の略≪最大≫を意味する
英単語です！
詰り「UWORD*line」で仮引数でポインタが示す実引数の
データの最大値を算出する関数です！
「line」は、一つながりの連続するデータを意味します！
序に関数の型「DWORD」は、「unsigned long」４バイト
整数で符号無しです！

（３－４－１１５－Ｂ）関数「MaxLine()」の【仮引数】説明

DWORD           Support::MaxLine(
    UWORD*      line,                               // データPtr
    int         size                                // サイズ
){

「UWORD*line,」は、連続するメモリ上データをポインタで
示す実引数のデータ列を示すポインタです！
「int size」は、計算するデータのサイズです！
序に「UWORD」は、「unsigned short」２バイト整数で
符号無しです！

（３－４－１１５－Ｃ）関数「MaxLine()」の
【ローカル変数】説明

){
    UWORD       data;                               // データ
    UWORD       temp;                               // データ：比較用

「UWORD data;」は、結果の最大値レジスターへ一時的な
置き場所！
「UWORD temp;」は、比較用データとして
仮引数「UWORD*line」から一旦、ＣＰＵ内部の高速
レジスターへ一時的な置き場所！

（３－４－１１５－Ｄ）関数「MaxLine()」の
【アルゴリズム】説明

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data < temp ){                          // 大きい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( (DWORD)data );                          //
}

「data = *line;」は、最初のデータを仮の最大値として
初期化！
「while(--size>=0) {・・ループ中身・・}」は、
ループ条件「(--size>=0)」で仮引数「int size」分ループ
中身を実行
ループ中身「temp=*line++;if(data<temp){data=temp;}」と
「temp=*line++;」で一時的にＣＰＵ内部高速レジスターに
取り出し、「if(data<temp){data=temp;}」で最大値の依り
大きい方を「data」にセット！
最後に関数の値として「return((DWORD)data);」と
キャスト演算で「DWORD型」に変換するのは、ループの
中身で「UWORD型」同士の操作を行う事で無駄なキャスト
演算（型変換）が起こらない様に考慮した為です！

（３－４－１１６）関数「DWORD MaxLine(
DWORD*line,int size);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

DWORD           Support::MaxLine(
    DWORD*      line,                               // データPtr
    int         size                                // サイズ
){
    DWORD       data;                               // データ
    DWORD       temp;                               // データ：比較用

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data < temp ){                          // 大きい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( (DWORD)data );                          //
}

（３－４－１１６－Ａ）関数名「MaxLine」の説明

「Max」は、英単語「maximum」の略≪最大≫を意味する
英単語です！
詰り「DWORD*line」で仮引数でポインタが示す実引数の
データの最大値を算出する関数です！
「line」は、一つながりの連続するデータを意味します！
序に関数の型「DWORD」は、「unsigned long」４バイト
整数で符号無しです！

（３－４－１１６－Ｂ）関数「MaxLine()」の【仮引数】説明

DWORD           Support::MaxLine(
    DWORD*      line,                               // データPtr
    int         size                                // サイズ
){

「DWORD*line,」は、連続するメモリ上データをポインタで
示す実引数のデータ列を示すポインタです！
「int size」は、計算するデータのサイズです！
序に「DWORD」は、「unsigned long」４バイト整数で
符号無しです！

（３－４－１１６－Ｃ）関数「MaxLine()」の
【ローカル変数】説明

){
    DWORD       data;                               // データ
    DWORD       temp;                               // データ：比較用

「DWORD data;」は、結果の最大値レジスターへ一時的な置
き場所！
「DWORD temp;」は、比較用データとして
仮引数「DWORD*line」から一旦、ＣＰＵ内部の高速
レジスターへ一時的な置き場所！

（３－４－１１６－Ｄ）関数「MaxLine()」の
【アルゴリズム】説明

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data < temp ){                          // 大きい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( (DWORD)data );                          //
}

「data = *line;」は、最初のデータを仮の最大値として
初期化！
「while(--size>=0) {・・ループ中身・・}」は、
ループ条件「(--size>=0)」で仮引数「int size」分ループ
中身を実行
ループ中身「temp=*line++;if(data<temp){data=temp;}」
と「temp=*line++;」で一時的にＣＰＵ内部高速
レジスターに取り出し、
「if(data<temp){data=temp;}」で最大値の依り大きい
方を「data」にセット！
最後に関数の値として「return((DWORD)data);」と
キャスト演算で「DWORD型」に変換するのは、ループの
中身で「DWORD型」同士の操作を行う事で無駄なキャスト
演算（型変換）が起こらない様に考慮した為です！

（３－４－１１７）関数「double MaxLine(
float*line,int size);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

double          Support::MaxLine(
    float*      line,                               // データPtr
    int         size                                // サイズ
){
    float       data;                               // データ
    float       temp;                               // データ：比較用

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data < temp ){                          // 大きい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( (double)data );                         //
}

（３－４－１１７－Ａ）関数名「MaxLine」の説明

「Max」は、英単語「maximum」の略≪最大≫を意味する
英単語です！
詰り「float*line」で仮引数でポインタが示す実引数の
データの最大値を算出する関数です！
「line」は、一つながりの連続するデータを意味します！
序に関数の型「double」は、倍精度浮動小数点型で
Ｃ言語では式の中で実数型ならばデフォルトの型に
成るからです！

（３－４－１１７－Ｂ）関数「MaxLine()」の【仮引数】説明

double          Support::MaxLine(
    float*      line,                               // データPtr
    int         size                                // サイズ
){

「float*line,」は、連続するメモリ上データをポインタで
示す実引数のデータ列を示すポインタです！
「float型」は単精度浮動小数点４バイトサイズです！
「int size」は、計算するデータのサイズです！

（３－４－１１７－Ｃ）関数「MaxLine()」の
【ローカル変数】説明

){
    float       data;                               // データ
    float       temp;                               // データ：比較用

「float data;」は、結果の最大値レジスターへ一時的な
置き場所！
「float temp;」は、比較用データとして
仮引数「float*line」から一旦、ＣＰＵ内部の高速
レジスターへ一時的な置き場所！

（３－４－１１７－Ｄ）関数「MaxLine()」の
【アルゴリズム】説明

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data < temp ){                          // 大きい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( (double)data );                         //
}

「data = *line;」は、最初のデータを仮の最大値として
初期化！
「while(--size>=0) {・・ループ中身・・}」は、
ループ条件「(--size>=0)」で仮引数「int size」分ループ
中身を実行！
ループ中身「temp=*line++;if(data>temp){data=temp;}」
と「temp=*line++;」で一時的にＣＰＵ内部高速
レジスターに取り出し、「if(data>temp){data=temp;}」で
最大値の依り大きい方を「data」にセット！
最後に関数の値として「return((double)data);」と
キャスト演算で「double型」に変換するのは、ループの
中身で「float型」同士の操作を行う事で無駄なキャスト
演算（型変換）が起こらない様に考慮した為です！

（３－４－１１８）関数「double MaxLine(
double*line,int size);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

double          Support::MaxLine(
    double*     line,                               // データPtr
    int         size                                // サイズ
){
    double      data;                               // データ
    double      temp;                               // データ：比較用

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data < temp ){                          // 大きい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( data );                                 //
}

（３－４－１１８－Ａ）関数名「MaxLine」の説明

「Max」は、英単語「maximum」の略≪最大≫を意味する
英単語です！
詰り「double*line」で仮引数でポインタが示す実引数の
データの最大値を算出する関数です！
「line」は、一つながりの連続するデータを意味します！
序に関数の型「double」は、倍精度浮動小数点型で
Ｃ言語では式の中で実数型ならばデフォルトの型に
成るからです！

（３－４－１１８－Ｂ）関数「MaxLine()」の【仮引数】説明

double          Support::MaxLine(
    double*     line,                               // データPtr
    int         size                                // サイズ
){

「double*line,」は、連続するメモリ上データを
ポインタで示す実引数のデータ列を示すポインタです！
「double型」は倍精度浮動小数点型８バイトサイズです！
「int size」は、計算するデータのサイズです！

（３－４－１１８－Ｃ）関数「MaxLine()」の
【ローカル変数】説明

){
    double      data;                               // データ
    double      temp;                               // データ：比較用

「double data;」は、結果の最大値レジスターへ一時的な
置き場所！
「double temp;」は、比較用データとして
仮引数「double*line」から一旦、ＣＰＵ内部の高速
レジスターへ一時的な置き場所！

（３－４－１１８－Ｄ）関数「MaxLine()」の
【アルゴリズム】説明

    data = *line;                                   // 初期値をセットし
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( data < temp ){                          // 大きい方を
            data = temp;                            // 新しい値にする
        }                                           //
    }                                               //
    return( data );                                 //
}

「data = *line;」は、最初のデータを仮の最大値として
初期化！
「while(--size>=0) {・・ループ中身・・}」は、
ループ条件「(--size>=0)」で仮引数「int size」分ループ
中身を実行
ループ中身「temp=*line++;if(data>temp){data=temp;}」
と「temp=*line++;」で一時的にＣＰＵ内部高速レジスター
に取り出し、
「if(data>temp){data=temp;}」で最大値の依り大きい方を
「data」にセット！
最後に関数の値として「return(data);」で結果の値を
返します！

（３－４－１１９）関数「int MinMaxLine(
BYTE*line,int size,int& maxData);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

int             Support::MinMaxLine(
    BYTE*       line,                               // データPtr
    int         size,                               // サイズ
    int&        maxData                             // 返値：最大値
){
    BYTE        minD;                               // データ：最小値
    BYTE        maxD;                               // データ：最大値
    BYTE        temp;                               // データ：比較用

    minD = *line;                                   // 初期値をセットし
    maxD = minD;                                    //
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( minD > temp ){                          // 小さいい方を
            minD = temp;                            // 新しい最大値にする
        }                                           //
        if( maxD < temp ){                          // 大きい方を
            maxD = temp;                            // 新しい最大値にする
        }                                           //
    }                                               //
    maxData = (int)maxD;                            // 最大値を返す
    return( (int)minD );                            // 最小値を返す
}

（３－４－１１９－Ａ）関数名「MinMaxLine」の説明

「Min」は、英単語「minimum」の略≪最小≫を意味する
英単語です！
「Max」は、英単語「maximum」の略≪最大≫を意味する
英単語です！
詰り「BYTE*line」で仮引数でポインタが示す実引数の
データの最小値と最大値を両方とも算出する関数です！
「line」は、一つながりの連続するデータを意味します！

（３－４－１１９－Ｂ）関数「MinMaxLine()」の【仮引数】説明

int             Support::MinMaxLine(
    BYTE*       line,                               // データPtr
    int         size,                               // サイズ
    int&        maxData                             // 返値：最大値
){

「BYTE*line,」は、連続するメモリ上データをポインタで
示す実引数のデータ列を示すポインタです！
「int size」は、計算するデータのサイズです！
「int& maxData」は、最大値を「int&」で仮引数に対応
する実引数に対して結果を返す為の仮引数です！

（３－４－１１９－Ｃ）関数「MinMaxLine()」の
【ローカル変数】説明

){
    BYTE        minD;                               // データ：最小値
    BYTE        maxD;                               // データ：最大値
    BYTE        temp;                               // データ：比較用

「BYTE minD;」は、結果の最小値です！
「BYTE maxD;」は、結果の最大値です！
「BYTE temp;」は、比較用データとして
仮引数「BYTE*line」から一旦、ＣＰＵ内部の高速
レジスターへ一時的な置き場所！

（３－４－１１９－Ｄ）関数「MinMaxLine()」の
【アルゴリズム】説明

    minD = *line;                                   // 初期値をセットし
    maxD = minD;                                    //
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( minD > temp ){                          // 小さいい方を
            minD = temp;                            // 新しい最大値にする
        }                                           //
        if( maxD < temp ){                          // 大きい方を
            maxD = temp;                            // 新しい最大値にする
        }                                           //
    }                                               //
    maxData = (int)maxD;                            // 最大値を返す
    return( (int)minD );                            // 最小値を返す
}

「minD = *line;」は、最初のデータを仮の最小値として
初期化！
「maxD = minD;」は、最初のデータを仮の最大値として
初期化！
「while(--size>=0) {・・ループ中身・・}」は、
ループ条件「(--size>=0)」で仮引数「int size」分
ループ中身を実行！
ループ中身「temp=*line++;if(minD>temp){minD=temp;}
if(minD<temp){minD=temp;}」と
「temp=*line++;」で一時的にＣＰＵ内部高速レジスターに
取り出し、
「if(minD>temp){minD=temp;}」で最小値の依り小さい
方を「minD」に「if(maxD<temp){maxD=temp;}」で最大値の
依り大きい方を「maxD」にセット！
「maxData=(int)maxD;」は、仮引数「int& maxData」に
キャスト演算で「int型」に変換後、ポインタ経由で対応
する実引数に値を返します！
最後に関数の値として「return((int)minD);」とキャスト
演算で「int型」に変換するのは、ループの中身で
「BYTE型」同士の操作を行う事で無駄なキャスト
演算（型変換）が起こらない様に考慮した為です！

（３－４－１２０）関数「int MinMaxLine(
short*line,int size,int& maxData);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

int             Support::MinMaxLine(
    short*      line,                               // データPtr
    int         size,                               // サイズ
    int&        maxData                             // 返値：最大値
){
    short       minD;                               // データ：最小値
    short       maxD;                               // データ：最大値
    short       temp;                               // データ：比較用

    minD = *line;                                   // 初期値をセットし
    maxD = minD;                                    //
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( minD > temp ){                          // 小さいい方を
            minD = temp;                            // 新しい最大値にする
        }                                           //
        if( maxD < temp ){                          // 大きい方を
            maxD = temp;                            // 新しい最大値にする
        }                                           //
    }                                               //
    maxData = (int)maxD;                            // 最大値を返す
    return( (int)minD );                            // 最小値を返す
}

（３－４－１２０－Ａ）関数名「MinMaxLine」の説明

「Min」は、英単語「minimum」の略≪最小≫を意味する
英単語です！
「Max」は、英単語「maximum」の略≪最大≫を意味する
英単語です！
詰り「short*line」で仮引数でポインタが示す実引数の
データの最小値と最大値を両方とも算出する関数です！
「line」は、一つながりの連続するデータを意味します！

（３－４－１２０－Ｂ）関数「MinMaxLine()」の【仮引数】説明

int             Support::MinMaxLine(
    short*      line,                               // データPtr
    int         size,                               // サイズ
    int&        maxData                             // 返値：最大値
){

「short*line,」は、連続するメモリ上データを
ポインタで示す実引数のデータ列を示すポインタです！
「int size」は、計算するデータのサイズです！
「int& maxData」は、最大値を「int&」で仮引数に対応す
る実引数に対して結果を返す為の仮引数です！

（３－４－１２０－Ｃ）関数「MinMaxLine()」の
【ローカル変数】説明

){
    short       minD;                               // データ：最小値
    short       maxD;                               // データ：最大値
    short       temp;                               // データ：比較用

「short minD;」は、結果の最小値です！
「short maxD;」は、結果の最大値です！
「short temp;」は、比較用データとして
仮引数「short*line」から一旦、ＣＰＵ内部の高速
レジスターへ一時的な置き場所！

（３－４－１２０－Ｄ）関数「MinMaxLine()」の
【アルゴリズム】説明

    minD = *line;                                   // 初期値をセットし
    maxD = minD;                                    //
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( minD > temp ){                          // 小さいい方を
            minD = temp;                            // 新しい最大値にする
        }                                           //
        if( maxD < temp ){                          // 大きい方を
            maxD = temp;                            // 新しい最大値にする
        }                                           //
    }                                               //
    maxData = (int)maxD;                            // 最大値を返す
    return( (int)minD );                            // 最小値を返す
}

「minD = *line;」は、最初のデータを仮の最小値として
初期化！
「maxD = minD;」は、最初のデータを仮の最大値として
初期化！
「while(--size>=0) {・・ループ中身・・}」は、
ループ条件「(--size>=0)」で仮引数「int size」分ループ
中身を実行
ループ中身「temp=*line++;if(minD>temp){minD=temp;}
if(minD<temp){minD=temp;}」と
「temp=*line++;」で一時的にＣＰＵ内部高速レジスターに
取り出し、
「if(minD>temp){minD=temp;}」で最小値の依り小さい
方を「minD」に
「if(maxD<temp){maxD=temp;}」で最大値の依り大きい
方を「maxD」にセット！
「maxData=(int)maxD;」は、仮引数「int& maxData」に
キャスト演算で「int型」に変換後、ポインタ経由で対応
する実引数に値を返します！
最後に関数の値として「return((int)minD);」と
キャスト演算で「int型」に変換するのは、ループの中身
で「short型」同士の操作を行う事で無駄なキャスト
演算（型変換）が起こらない様に考慮した為です！

（３－４－１２１）関数「int MinMaxLine(
int*line,int size,int& maxData);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

int             Support::MinMaxLine(
    int*        line,                               // データPtr
    int         size,                               // サイズ
    int&        maxData                             // 返値：最大値
){
    int         minD;                               // データ：最小値
    int         maxD;                               // データ：最大値
    int         temp;                               // データ：比較用

    minD = *line;                                   // 初期値をセットし
    maxD = minD;                                    //
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( minD > temp ){                          // 小さいい方を
            minD = temp;                            // 新しい最大値にする
        }                                           //
        if( maxD < temp ){                          // 大きい方を
            maxD = temp;                            // 新しい最大値にする
        }                                           //
    }                                               //
    maxData = maxD;                                 // 最大値を返す
    return( minD );                                 // 最小値を返す
}

（３－４－１２１－Ａ）関数名「MinMaxLine」の説明

「Min」は、英単語「minimum」の略≪最小≫を意味する
英単語です！
「Max」は、英単語「maximum」の略≪最大≫を意味する
英単語です！
詰り「int*line」で仮引数でポインタが示す実引数の
データの最小値と最大値を両方とも算出する関数です！
「line」は、一つながりの連続するデータを意味します！

（３－４－１２１－Ｂ）関数「MinMaxLine()」の
【仮引数】説明

int             Support::MinMaxLine(
    int*        line,                               // データPtr
    int         size,                               // サイズ
    int&        maxData                             // 返値：最大値
){

「int*line,」は、連続するメモリ上データをポインタで
示す実引数のデータ列を示すポインタです！
「int size」は、計算するデータのサイズです！
「int& maxData」は、最大値を「int&」で仮引数に対応する
実引数に対して結果を返す為の仮引数です！

（３－４－１２１－Ｃ）関数「MinMaxLine()」の
【ローカル変数】説明

){
    int         minD;                               // データ：最小値
    int         maxD;                               // データ：最大値
    int         temp;                               // データ：比較用

「int minD;」は、結果の最小値です！
「int maxD;」は、結果の最大値です！
「int temp;」は、比較用データとして
仮引数「int*line」から一旦、ＣＰＵ内部の高速
レジスターへ一時的な置き場所！

（３－４－１２１－Ｄ）関数「MinMaxLine()」の
【アルゴリズム】説明

    minD = *line;                                   // 初期値をセットし
    maxD = minD;                                    //
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( minD > temp ){                          // 小さいい方を
            minD = temp;                            // 新しい最大値にする
        }                                           //
        if( maxD < temp ){                          // 大きい方を
            maxD = temp;                            // 新しい最大値にする
        }                                           //
    }                                               //
    maxData = maxD;                                 // 最大値を返す
    return( minD );                                 // 最小値を返す
}

「minD = *line;」は、最初のデータを仮の最小値として
初期化！
「maxD = minD;」は、最初のデータを仮の最大値として
初期化！
「while(--size>=0) {・・ループ中身・・}」は、
ループ条件「(--size>=0)」で仮引数「int size」分ループ
中身を実行
ループ中身「temp=*line++;if(minD>temp){minD=temp;}
if(minD<temp){minD=temp;}」と
「temp=*line++;」で一時的にＣＰＵ内部高速レジスターに
取り出し、
「if(minD>temp){minD=temp;}」で最小値の依り小さい
方を「minD」に
「if(maxD<temp){maxD=temp;}」で最大値の依り大きい
方を「maxD」にセット！
「maxData=maxD;」は、仮引数「int& maxData」に結果
として返し、最後に関数の値として「return(minD);」と
関数の結果を返します！

（３－４－１２２）関数「DWORD MinMaxLine(
UWORD*line,int size,DWORD& maxData);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

DWORD           Support::MinMaxLine(
    UWORD*      line,                               // データPtr
    int         size,                               // サイズ
    DWORD&      maxData                             // 返値：最大値
){
    UWORD       minD;                               // データ：最小値
    UWORD       maxD;                               // データ：最大値
    UWORD       temp;                               // データ：比較用

    minD = *line;                                   // 初期値をセットし
    maxD = minD;                                    //
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( minD > temp ){                          // 小さいい方を
            minD = temp;                            // 新しい最大値にする
        }                                           //
        if( maxD < temp ){                          // 大きい方を
            maxD = temp;                            // 新しい最大値にする
        }                                           //
    }                                               //
    maxData = (DWORD)maxD;                          // 最大値を返す
    return( (DWORD)minD );                          // 最小値を返す
}

（３－４－１２２－Ａ）関数名「MinMaxLine」の説明

「Min」は、英単語「minimum」の略≪最小≫を意味する
英単語です！
「Max」は、英単語「maximum」の略≪最大≫を意味する
英単語です！
詰り「UWORD*line」で仮引数でポインタが示す実引数の
データの最小値と最大値を両方とも算出する関数です！
「line」は、一つながりの連続するデータを意味します！

（３－４－１２２－Ｂ）関数「MinMaxLine()」の【仮引数】説明

DWORD           Support::MinMaxLine(
    UWORD*      line,                               // データPtr
    int         size,                               // サイズ
    DWORD&      maxData                             // 返値：最大値
){

「UWORD*line,」は、連続するメモリ上データをポインタで
示す実引数の
データ列を示すポインタです！
「int size」は、計算するデータのサイズです！
「DWORD& maxData」は、最大値を「DWORD&」で
仮引数に対応する実引数に対して結果を返す為の仮引数
です！

（３－４－１２２－Ｃ）関数「MinMaxLine()」の
【ローカル変数】説明

){
    UWORD       minD;                               // データ：最小値
    UWORD       maxD;                               // データ：最大値
    UWORD       temp;                               // データ：比較用

「UWORD minD;」は、結果の最小値です！
「UWORD maxD;」は、結果の最大値です！
「UWORD temp;」は、比較用データとして
仮引数「UWORD*line」から一旦、ＣＰＵ内部の高速
レジスターへ一時的な置き場所！

（３－４－１２２－Ｄ）関数「MinMaxLine()」の
【アルゴリズム】説明

    minD = *line;                                   // 初期値をセットし
    maxD = minD;                                    //
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( minD > temp ){                          // 小さいい方を
            minD = temp;                            // 新しい最大値にする
        }                                           //
        if( maxD < temp ){                          // 大きい方を
            maxD = temp;                            // 新しい最大値にする
        }                                           //
    }                                               //
    maxData = (DWORD)maxD;                          // 最大値を返す
    return( (DWORD)minD );                          // 最小値を返す
}

「minD = *line;」は、最初のデータを仮の最小値として
初期化！
「maxD = minD;」は、最初のデータを仮の最大値として
初期化！
「while(--size>=0) {・・ループ中身・・}」は、
ループ条件「(--size>=0)」で仮引数「int size」分ループ
中身を実行
ループ中身「temp=*line++;if(minD>temp){minD=temp;}
if(minD<temp){minD=temp;}」と「temp=*line++;」で
一時的にＣＰＵ内部高速レジスターに取り出し、
「if(minD>temp){minD=temp;}」で最小値の依り小さい
方を「minD」に
「if(maxD<temp){maxD=temp;}」で最大値の依り大きい
方を「maxD」にセット！
「maxData=(DWORD)maxD;」は、
仮引数「DWORD& maxData」にキャスト演算で
「DWORD型」に変換後、ポインタ経由で対応する
実引数に値を返します！
最後に関数の値として「return((DWORD)minD);」と
キャスト演算で「DWORD型」に変換するのは、ループの
中身で「short型」同士の操作を行う事で無駄なキャスト
演算（型変換）が起こらない様に考慮した為です！

（３－４－１２３）関数「DWORD MinMaxLine(
DWORD*line,int size,DWORD& maxData);」の説明

この関数の本体は、ファイル「Support.cpp」に格納
されて居て次の様に

DWORD           Support::MinMaxLine(
    DWORD*      line,                               // データPtr
    int         size,                               // サイズ
    DWORD&      maxData                             // 返値：最大値
){
    DWORD       minD;                               // データ：最小値
    DWORD       maxD;                               // データ：最大値
    DWORD       temp;                               // データ：比較用

    minD = *line;                                   // 初期値をセットし
    maxD = minD;                                    //
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( minD > temp ){                          // 小さいい方を
            minD = temp;                            // 新しい最大値にする
        }                                           //
        if( maxD < temp ){                          // 大きい方を
            maxD = temp;                            // 新しい最大値にする
        }                                           //
    }                                               //
    maxData = (unsigned)maxD;                       // 最大値を返す
    return( (unsigned)minD );                       // 最小値を返す
}

（３－４－１２３－Ａ）関数名「MinMaxLine」の説明

「Min」は、英単語「minimum」の略≪最小≫を意味する
英単語です！
「Max」は、英単語「maximum」の略≪最大≫を意味する
英単語です！
詰り「DWORD*line」で仮引数でポインタが示す実引数の
データの最小値と最大値を両方とも算出する関数です！
「line」は、一つながりの連続するデータを意味します！

（３－４－１２３－Ｂ）関数「MinMaxLine()」の【仮引数】説明

DWORD           Support::MinMaxLine(
    DWORD*      line,                               // データPtr
    int         size,                               // サイズ
    DWORD&      maxData                             // 返値：最大値
){

「DWORD*line,」は、連続するメモリ上データをポインタで
示す実引数のデータ列を示すポインタです！
「int size」は、計算するデータのサイズです！
「DWORD& maxData」は、最大値を「DWORD&」で仮引数に対応
する実引数に対して結果を返す為の仮引数です！

（３－４－１２３－Ｃ）関数「MinMaxLine()」の
【ローカル変数】説明

){
    DWORD       minD;                               // データ：最小値
    DWORD       maxD;                               // データ：最大値
    DWORD       temp;                               // データ：比較用

「DWORD minD;」は、結果の最小値です！
「DWORD maxD;」は、結果の最大値です！
「DWORD temp;」は、比較用データとして
仮引数「DWORD*line」から一旦、ＣＰＵ内部の高速
レジスターへ一時的な置き場所！

（３－４－１２３－Ｄ）関数「MinMaxLine()」の
【アルゴリズム】説明

    minD = *line;                                   // 初期値をセットし
    maxD = minD;                                    //
    while( --size >= 0 ){                           // サイズ分を繰返し
        temp = *line++;                             // 比較値を取り出し
        if( minD > temp ){                          // 小さいい方を
            minD = temp;                            // 新しい最大値にする
        }                                           //
        if( maxD < temp ){                          // 大きい方を
            maxD = temp;                            // 新しい最大値にする
        }                                           //
    }                                               //
    maxData = (unsigned)maxD;                       // 最大値を返す
    return( (unsigned)minD );                       // 最小値を返す
}

「minD = *line;」は、最初のデータを仮の最小値として
初期化！
「maxD = minD;」は、最初のデータを仮の最大値として
初期化！
「while(--size>=0) {・・ループ中身・・}」は、
ループ条件「(--size>=0)」で仮引数「int size」分ループ
中身を実行
ループ中身「temp=*line++;if(minD>temp){minD=temp;}
if(minD<temp){minD=temp;}」と
「temp=*line++;」で一時的にＣＰＵ内部高速レジスターに
取り出し、
「if(minD>temp){minD=temp;}」で最小値の依り小さい
方を「minD」に
「if(maxD<temp){maxD=temp;}」で最大値の依り大きい
方を「maxD」にセット！
「maxData=(unsigned)maxD;」は、
仮引数「DWORD& maxData」に結果として返し最後に
関数の値として「return((unsigned)minD);」と関数の結果を
返します！
☆注意☆「(unsigned)」と殊更にキャスト演算で
「符号無し」を示して居るのは、コンパイラシステムと言う
依りも読む人間「作者の私に対しては意味を忘れない様に
強調」している為です！

★備考★
解説『解説クラスＴｙｐｅＡｒｒａｙ』でも記載したが、
ｎｏｔｅエディタの変な特性でコピペした文章の半角「*」
が消されたり、空白「 」が消される事が多々あります！
注意して手作業で修正している筈ですが、必ず、ｃｏｄｅ
機能で表示して居る物を正しいとして確認して下さい

取り敢えず、今日（２月１９）の講義はココまで
お疲れ様です！マダ続きが有りますが、それは後日！！
続きは、この解説が、大きく成り過ぎたので
解説『解説クラスＳｕｐｐｏｒｔ続（３）』に続きます！

文末