解説クラスＳｕｐｐｏｒｔ続き

解説クラスＳｕｐｐｏｒｔ続き

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

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

（３－４－３６）型変換を伴う関数一覧

型変換Ａ

関数「up_movb()」から「up_movｌ()」と基本、
整数型の同じデータ型の「source to destination」と
元から先（宛先）へコピーする関数を説明しましたが、
上記の表の様に「型変換」を伴い他の整数型のデータを
コピーする関数を説明して行きます！
もう一度、復習として「BYTE」は、「unsigned char」型で
「UWORD」「unsigned short」型です！
更に「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です。
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ移動
と言う依り、コピー動作を行う物です！
使用頻度が多いと考えられたので省略して短く表現しま
した！

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

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

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

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

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

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

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

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

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

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

「if(l>=4){・・中身・・}」は、条件「l>=4」詰り
データ転送長さ「l」が４以上なら中身のブロックで処理
します！
関数「up_movb()」では、１６と多めにしていましたが、
ココでは４です！
後は、同じ様に「source to destination」と元から
先（宛先）へコピーする中身の処理に比べてループ条件判断
の割合と実際の必要な動作に不要な部分を減らす（今回は、
四分の一）に成る事は理解して頂けたと思います！
「*pd++=*ps++;」は、単純な転送と同じですがＣ言語の
ルール≪送り先の大きな型（今回はshort型）に変換して
転送≫に従い書き込まれます！
アルゴリズムの大枠に関しては関数「up_movb()」の説明を
参考にして下さい！
☆注意☆回数を４回にして居るのは、そこまでギリギリ
高速動作を考える依りもコードのサイズを程々にする事を
考えたからです！

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

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

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

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

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

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

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

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

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

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

「if(l>=4){・・中身・・}」は、条件「l>=4」詰り
データ転送長さ「l」が４以上なら中身のブロックで処理
します！
関数「up_movb()」では、１６と多めにしていましたが、
ココでは４です！
後は、同じ様に
「source to destination」と元から先へコピーする中身の
処理に比べてループ条件判断の割合と実際の必要な動作に
不要な部分を減らす（今回は、四分の一）に成る事は理解
して頂けたと思います！
「*pd++=*ps++;」は、単純な転送と同じですがＣ言語の
ルール≪送り先の大きな型（今回はshort型）に変換して
転送≫に従い書き込まれます！
アルゴリズムの大枠に関しては関数「up_movb()」の説明を
参考にして下さい！
☆注意☆回数を４回にして居るのは、そこまでギリギリ
高速動作を考える依りもコードのサイズを程々にする事を
考えたからです！

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

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

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

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

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

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

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

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

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

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

「if(l>=4){・・中身・・}」は、条件「l>=4」詰り
データ転送長さ「l」が４以上なら中身のブロックで処理
します！
関数「up_movb()」では、１６と多めにしていましたが、
ココでは４です！
後は、同じ様に「source to destination」と元から
先（宛先）へコピーする中身の処理に比べてループ条件判断
の割合と実際の必要な動作に不要な部分を減らす（今回は、
四分の一）に成る事は理解して頂けたと思います！
「*pd++=*ps++;」は、単純な転送と同じですがＣ言語の
ルール≪送り先の大きな型（今回はshort型）に変換して
転送≫に従い書き込まれます！
アルゴリズムの大枠に関しては関数「up_movb()」の説明を
参考にして下さい！
☆注意☆回数を４回にして居るのは、そこまでギリギリ
高速動作を考える依りもコードのサイズを程々にする事を
考えたからです！

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

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

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

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

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

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

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

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

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

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

「if(l>=4){・・中身・・}」は、条件「l>=4」詰り
データ転送長さ「l」が４以上なら中身のブロックで処理
します！
関数「up_movb()」では、１６と多めにしていましたが、
ココでは４です！
後は、同じ様に「source to destination」と元から
先（宛先）へコピーする中身の処理に比べてループ条件
判断の割合と実際の必要な動作に不要な部分を減らす（
今回は、四分の一）に成る事は理解して頂けたと思いま
す！
「*pd++=*ps++;」は、単純な転送と同じですがＣ言語の
ルール≪送り先の大きな型（今回はshort型）に変換して
転送≫に従い書き込まれます！
アルゴリズムの大枠に関しては関数「up_movb()」の
説明を参考にして下さい！
☆注意☆回数を４回にして居るのは、そこまでギリギリ
高速動作を考える依りもコードのサイズを程々にする事を
考えたからです！

（３－４－４１）関数「void up_movs2b(
short*ps,BYTE*pd,int l);」の説明

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

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

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

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

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

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

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

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

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

「if(l>=8){・・中身・・}」は、条件「l>=8」詰りデータ
転送長さ「l」が８以上なら中身のブロックで処理します！
関数「up_movb()」では、１６と多めにしていましたが、
ココでは８です！後は、同じ様に
「source to destination」と元から先へコピーする中身の
処理に比べてループ条件判断の割合と実際の必要な動作に
不要な部分を減らす（今回は、八分の一）に成る事は理解
して頂けたと思います！
「*pd++ = (BYTE)*ps++;」は、単純な転送と同じですが
明示的にＣ言語の型変換「(BYTE)」に従い書き込まれます！
今回は、「short型」の下位１バイト分のデータが
「BYTE型」データとして書き込まれます！
アルゴリズムの大枠に関しては関数「up_movb()」の説明を
参考にして下さい！
☆注意☆回数を８回にして居るのは、そこまでギリギリ
高速動作を考える依りもコードのサイズを程々にする事を
考えたからです！
そして関数「up_movc2l()」の様に４回でなく８回なのは、
若干、この関数「up_movs2b()」の方が使用頻度が多い為で
調整の為の数です！

（３－４－４２）関数「void up_movs2c(
shortps,charpd,int l);」の説明

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

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

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

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

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

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

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

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

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

「if(l>=8){・・中身・・}」は、条件「l>=8」詰り
データ転送長さ「l」が８以上なら中身のブロックで処理
します！
関数「up_movb()」では、１６と多めにしていましたが、
ココでは８です！
後は、同じ様に「source to destination」と元から
先（宛先）へコピーする中身の処理に比べてループ条件
判断の割合と実際の必要な動作に不要な部分を減らす（
今回は、八分の一）に成る事は理解して頂けたと思います！
「*pd++ = (char)*ps++;」は、単純な転送と同じですが
明示的にＣ言語の型変換「(char)」に従い書き込まれます！
今回は、「short型」の下位１バイト分のデータが
「char型」データとして書き込まれます！
アルゴリズムの大枠に関しては関数「up_movb()」の説明を
参考にして下さい！
☆注意☆回数を８回にして居るのは、そこまでギリギリ
高速動作を考える依りもコードのサイズを程々にする事を
考えたからです！
そして関数「up_movc2l()」の様に４回でなく８回なのは、
若干、この関数「up_movs2c()」の方が使用頻度が多い
為で調整の為の数です！

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

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

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

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

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

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

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

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

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

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

「if(l>=4){・・中身・・}」は、条件「l>=4」詰り
データ転送長さ「l」が４以上なら中身のブロックで処理
します！
関数「up_movb()」では、１６と多めにしていましたが、
ココでは４です！
後は、同じ様に「source to destination」と元から
先（宛先）へコピーする中身の処理に比べてループ条件判断
の割合と実際の必要な動作に不要な部分を減らす（今回は、
四分の一）に成る事は理解して頂けたと思います！
「*pd++=*ps++;」は、単純な転送と同じですがＣ言語の
ルール≪送り先の大きな型（今回はlong型）に変換して
転送≫に従い書き込まれます！
アルゴリズムの大枠に関しては関数「up_movb()」の説明を
参考にして下さい！
☆注意☆回数を４回にして居るのは、そこまでギリギリ
高速動作を考える依りもコードのサイズを程々にする事を
考えたからです！

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

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

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

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

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

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

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

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

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

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

「if(l>=8){・・中身・・}」は、条件「l>=8」詰り
データ転送長さ「l」が８以上なら中身のブロックで処理
します！
関数「up_movb()」では、１６と多めにしていましたが、
ココでは８です！後は、同じ様に
「source to destination」と元から先へコピーする中身の
処理に比べてループ条件判断の割合と実際の必要な動作に
不要な部分を減らす（今回は、八分の一）に成る事は理解
して頂けたと思います！
「*pd++ = (BYTE)*ps++;」は、単純な転送と同じですが
明示的にＣ言語の型変換「(BYTE)」に従い書き込まれます！
今回は、「long型」の下位１バイト分のデータが
「BYTE型」データとして書き込まれます！
アルゴリズムの大枠に関しては関数「up_movb()」の説明を
参考にして下さい！
☆注意☆回数を８回にして居るのは、そこまでギリギリ
高速動作を考える依りもコードのサイズを程々にする事を
考えたからです！
そして関数「up_movc2l()」の様に４回でなく８回なのは、
若干、この関数「up_movl2b()」の方が使用頻度が多い為で
調整の為の数です！

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

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

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

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

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

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

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

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

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

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

「if(l>=8){・・中身・・}」は、条件「l>=8」詰り
データ転送長さ「l」が８以上なら中身のブロックで処理
します！
関数「up_movb()」では、１６と多めにしていましたが、
ココでは８です！
後は、同じ様に「source to destination」と元から
先（宛先）へコピーする中身の処理に比べてループ条件判断
の割合と実際の必要な動作に不要な部分を減らす（今回は、
八分の一）に成る事は理解して頂けたと思います！
「*pd++ = (char)*ps++;」は、単純な転送と同じですが
明示的にＣ言語の型変換「(char)」に従い書き込まれます！
今回は、「long型」の下位１バイト分のデータが
「char型」データとして書き込まれます！
アルゴリズムの大枠に関しては関数「up_movb()」の説明を
参考にして下さい！
☆注意☆回数を８回にして居るのは、そこまでギリギリ
高速動作を考える依りもコードのサイズを程々にする事を
考えたからです！
そして関数「up_movc2l()」の様に４回でなく８回なのは、
若干、この関数「up_movl2c()」の方が使用頻度が多い為で
調整の為の数です！

（３－４－４６）関数「void up_movl2s(long*ps,short*pd,int l);」の説明

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

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

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

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

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

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

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

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

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

「if(l>=8){・・中身・・}」は、条件「l>=8」詰り
データ転送長さ「l」が８以上なら中身のブロックで処理
します！
関数「up_movb()」では、１６と多めにしていましたが、
ココでは８です！
後は、同じ様に「source to destination」と元から
先（宛先）へコピーする中身の処理に比べてループ条件判
断の割合と実際の必要な動作に不要な部分を減らす（今回は
八分の一）に成る事は理解して頂けたと思います！
「*pd++ = (short)*ps++;」は、単純な転送と同じですが
明示的にＣ言語の型変換「(short)」に従い書き込まれま
す！
今回は、「long型」の下位１バイト分のデータが
「short型」データとして書き込まれます！
アルゴリズムの大枠に関しては関数「up_movb()」の説明を
参考にして下さい！
☆注意☆回数を８回にして居るのは、そこまでギリギリ
高速動作を考える依りもコードのサイズを程々にする事を
考えたからです！
そして関数「up_movc2l()」の様に４回でなく８回なのは、
若干、この関数「up_movl2s()」の方が使用頻度が多い為で
調整の為の数です！

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

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

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

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

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

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

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

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

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

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

「if(l>=4){・・中身・・}」は、条件「l>=4」詰り、
データ転送長さ「l」が４以上なら中身のブロックで処理
します！
関数「up_movb()」では、１６と多めにしていましたが、
ココでは４です！
後は、同じ様に「source to destination」と元から
先（宛先）へコピーする中身の処理に比べてループ条件判断
の割合と実際の必要な動作に不要な部分を減らす（今回は、
八分の一）に成る事は理解して頂けたと思います！
「*pd++ = (long)*ps++;」は、単純な転送と同じですが
明示的にＣ言語の型変換「(long)」に従い書き込まれます！
今回は、「UWORD型」の下位１バイト分のデータが
「long型」データとして書き込まれます！
アルゴリズムの大枠に関しては関数「up_movb()」の説明を
参考にして下さい！
☆注意☆回数を４回にして居るのは、そこまでギリギリ
高速動作を考える依りもコードのサイズを程々にする事を
考えたからです！

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

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

void            Support::up_movb_inc(
    BYTE        *ps,                            // 転送元へのポインタ
    BYTE        *pd,                            // 転送先へのポインタ
    int         l,                              // 転送する数量
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    int         c8;                             // ８を示す定数値

    c8 = 8;                                     // 定数８セット
    if( l >= c8 ){                              // ８単位以上なら
        l -= c8;                                // DownCuntを８単位
        do{                                     // 毎に進め８単位
            *pd = *ps;                          // 毎に転送する
            ps += incS;                         // ＳのPtrを増加
            pd += incD;                         // Ｄの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 -= c8 ) > 0 );              //
        l += c8;                                // DownCuntを８単位戻
    }                                           // す
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = *ps;                              // 転送する
        ps += incS;                             // ＳのPtrを増加
        pd += incD;                             // ＤのPtrを増加
    }                                           //
}

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

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

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

void            Support::up_movb_inc(
    BYTE        *ps,                            // 転送元へのポインタ
    BYTE        *pd,                            // 転送先へのポインタ
    int         l,                              // 転送する数量
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「BYTE*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「BYTE*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_movb_inc()」の
【ローカル変数】説明

){
    int         c8;                             // ８を示す定数値

「int c8;」は、定数値「８を示す値」を格納する変数
です！何故、初期値「int c8=8;」と記載せずに
アルゴリズム中に代入しているかと言うと
コンパイラシステムに依っては、私の意図した≪ＣＰＵの
高速レジスターに割り当てる≫で無く、モット実行速度に
影響を及ぼす機械コードに変換する場合が在り、
この記述に落ち着いたのです！
勿論、名称先頭の「c」はコンスト定数の意味です！

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

    c8 = 8;                                     // 定数８セット
    if( l >= c8 ){                              // ８単位以上なら
        l -= c8;                                // DownCuntを８単位
        do{                                     // 毎に進め８単位
            *pd = *ps;                          // 毎に転送する
            ps += incS;                         // ＳのPtrを増加
            pd += incD;                         // Ｄの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 -= c8 ) > 0 );              //
        l += c8;                                // DownCuntを８単位戻
    }                                           // す
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = *ps;                              // 転送する
        ps += incS;                             // ＳのPtrを増加
        pd += incD;                             // ＤのPtrを増加
    }                                           //
}

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

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

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

void            Support::up_movs_inc(
    short       *ps,                            // 転送元へのポインタ
    short       *pd,                            // 転送先へのポインタ
    int         l,                              // 転送する数量
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    int         c8;                             // ８を示す定数値

    c8 = 8;                                     // 定数８セット
    if( l >= c8 ){                              // ８単位以上なら
        l -= c8;                                // DownCuntを８単位
        do{                                     // 毎に進め８単位
            *pd = *ps;                          // 毎に転送する
            ps += incS;                         // ＳのPtrを増加
            pd += incD;                         // Ｄの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 -= c8 ) > 0 );              //
        l += c8;                                // DownCuntを８単位戻
    }                                           // す
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = *ps;                              // 転送する
        ps += incS;                             // ＳのPtrを増加
        pd += incD;                             // ＤのPtrを増加
    }                                           //
}

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

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

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

void            Support::up_movs_inc(
    short       *ps,                            // 転送元へのポインタ
    short       *pd,                            // 転送先へのポインタ
    int         l,                              // 転送する数量
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「short*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「short*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_movs_inc()」の
【ローカル変数】説明

){
    int         c8;                             // ８を示す定数値

「int c8;」は、定数値「８を示す値」を格納する変数
です！何故、初期値「int c8=8;」と記載せずに
アルゴリズム中に代入しているかと言うと
コンパイラシステムに依っては、私の意図した≪ＣＰＵの
高速レジスターに割り当てる≫で無く、
モット実行速度に影響を及ぼす機械コードに変換する場合が
在り、この記述に落ち着いたのです！
勿論、名称先頭の「c」はコンスト定数の意味です！

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

    c8 = 8;                                     // 定数８セット
    if( l >= c8 ){                              // ８単位以上なら
        l -= c8;                                // DownCuntを８単位
        do{                                     // 毎に進め８単位
            *pd = *ps;                          // 毎に転送する
            ps += incS;                         // ＳのPtrを増加
            pd += incD;                         // Ｄの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 -= c8 ) > 0 );              //
        l += c8;                                // DownCuntを８単位戻
    }                                           // す
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = *ps;                              // 転送する
        ps += incS;                             // ＳのPtrを増加
        pd += incD;                             // ＤのPtrを増加
    }                                           //
}

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

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

void            Support::up_movl_inc(
    long        *ps,                            // 転送元へのポインタ
    long        *pd,                            // 転送先へのポインタ
    int         l,                              // 転送する数量
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    int         c4;                             // ４を示す定数値

    c4 = 4;                                     // 定数４セット
    if( l >= c4 ){                              // ４単位以上なら
        l -= c4;                                // DownCuntを４単位
        do{                                     // 毎に進め４単位
            *pd = *ps;                          // 毎に転送する
            ps += incS;                         // ＳのPtrを増加
            pd += incD;                         // ＤのPtrを増加
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= c4 ) > 0 );              //
        l += c4;                                // DownCuntを４単位戻
    }                                           // す
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = *ps;                              // 転送する
        ps += incS;                             // ＳのPtrを増加
        pd += incD;                             // ＤのPtrを増加
    }                                           //
}

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

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

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

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

void            Support::up_movl_inc(
    long        *ps,                            // 転送元へのポインタ
    long        *pd,                            // 転送先へのポインタ
    int         l,                              // 転送する数量
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「long*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「long*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_movl_inc()」の
【ローカル変数】説明

){
    int         c4;                             // ４を示す定数値

「int c4;」は、定数値「４を示す値」を格納する
変数です！
何故、初期値「int c4=4;」と記載せずにアルゴリズム中に
代入しているかと言うとコンパイラシステムに依っては、
私の意図した≪ＣＰＵの高速レジスターに割り当てる≫で
無く、モット実行速度に影響を及ぼす機械コードに変換す
る場合が在り、この記述に落ち着いたのです！
勿論、名称先頭の「c」はコンスト定数の意味です！

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

    c4 = 4;                                     // 定数４セット
    if( l >= c4 ){                              // ４単位以上なら
        l -= c4;                                // DownCuntを４単位
        do{                                     // 毎に進め４単位
            *pd = *ps;                          // 毎に転送する
            ps += incS;                         // ＳのPtrを増加
            pd += incD;                         // ＤのPtrを増加
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
            *pd = *ps;                          //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= c4 ) > 0 );              //
        l += c4;                                // DownCuntを４単位戻
    }                                           // す
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = *ps;                              // 転送する
        ps += incS;                             // ＳのPtrを増加
        pd += incD;                             // ＤのPtrを増加
    }                                           //
}

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

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

void        Support::up_movi_inc(
    int     *ps,                                // 転送元へのポインタ
    int     *pd,                                // 転送先へのポインタ
    int     l,                                  // 転送する数量
    int     incS,                               // 増分：転送元 
    int     incD                                // 増分：転送先 
){
    up_movl_inc( (long*)ps, (long*)pd,          // キャストして実行
                            l, incS, incD );    //
}

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

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

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

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

void        Support::up_movi_inc(
    int     *ps,                                // 転送元へのポインタ
    int     *pd,                                // 転送先へのポインタ
    int     l,                                  // 転送する数量
    int     incS,                               // 増分：転送元 
    int     incD                                // 増分：転送先 
){

「int*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「int*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_movi_inc()」の
【アルゴリズム】説明

){
    up_movl_inc( (long*)ps, (long*)pd,          // キャストして実行
                            l, incS, incD );    //
}

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

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

void        Support::up_movv_inc(
    void    *ps,                                // 転送元へのポインタ
    void    *pd,                                // 転送先へのポインタ
    int     l,                                  // 転送する数量
    int     incS,                               // 増分：転送元 
    int     incD                                // 増分：転送先 
){
    up_movb_inc( (BYTE*)ps, (BYTE*)pd,          // キャストして実行
                            l, incS, incD );    //
}

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

（３－４－５２－Ａ）関数名「up_movv_inc」の説明

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

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

void        Support::up_movv_inc(
    void    *ps,                                // 転送元へのポインタ
    void    *pd,                                // 転送先へのポインタ
    int     l,                                  // 転送する数量
    int     incS,                               // 増分：転送元 
    int     incD                                // 増分：転送先 
){

「voidps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「voidpd,」は、「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_movv_inc()」の
【アルゴリズム】説明

){
    up_movb_inc( (BYTE*)ps, (BYTE*)pd,          // キャストして実行
                            l, incS, incD );    //
}

単に仮引数「void ps,」仮引数「void pd,」を型変換
キャストして「(BYTE)pd」・「(BYTE)pd」と置き換え
関数「up_movb_inc((BYTE*)ps,(BYTE*)pd,l,inc);」を
実行して居るだけです！
☆注意☆連続して処理すると言うか画像では水平方向に
「source to destination」と元から先へコピーする
関数「up_movv」の垂直方向版と考えて作成したダケノ物で
実際には、殆ど使用して無い筈です

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

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

２０２４年２月１４続講

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

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

void            Support::up_movb2s_inc(
    BYTE        *ps,                            // 転送元へのポインタ
    short       *pd,                            // 転送先へのポインタ
    int         l,                              // 転送する数量
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    int         c4;                             // ４を示す定数値

    c4 = 4;                                     // 定数４セット
    if( l >= c4 ){                              // ４単位以上なら
        l -= c4;                                // DownCuntを４単位
        do{                                     // 毎に進め４単位
            *pd = (short)*ps;                   // 毎に転送する
            ps += incS;                         // ＳのPtrを増加
            pd += incD;                         // ＤのPtrを増加
            *pd = (short)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (short)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (short)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= c4 ) > 0 );              //
        l += c4;                                // DownCuntを４単位戻
    }                                           // す
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (short)*ps;                       // 転送する
        ps += incS;                             // ＳのPtrを増加
        pd += incD;                             // ＤのPtrを増加
    }                                           //
}

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

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

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

void            Support::up_movb2s_inc(
    BYTE        *ps,                            // 転送元へのポインタ
    short       *pd,                            // 転送先へのポインタ
    int         l,                              // 転送する数量
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「BYTE*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_movb2s_inc()」の
【ローカル変数】説明

){
    int         c4;                             // ４を示す定数値

「int c4;」は、定数値「４を示す値」を格納する変数で
す！
何故、初期値「int c4=4;」と記載せずにアルゴリズム中に
代入しているかと言うとコンパイラシステムに依っては、
私の意図した≪ＣＰＵの高速レジスターに割り当てる≫で
無く、モット実行速度に影響を及ぼす機械コードに変換す
る場合が在り、この記述に落ち着いたのです！
勿論、名称先頭の「c」はコンスト定数の意味です！

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

    c4 = 4;                                     // 定数４セット
    if( l >= c4 ){                              // ４単位以上なら
        l -= c4;                                // DownCuntを４単位
        do{                                     // 毎に進め４単位
            *pd = (short)*ps;                   // 毎に転送する
            ps += incS;                         // ＳのPtrを増加
            pd += incD;                         // ＤのPtrを増加
            *pd = (short)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (short)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (short)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= c4 ) > 0 );              //
        l += c4;                                // DownCuntを４単位戻
    }                                           // す
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (short)*ps;                       // 転送する
        ps += incS;                             // ＳのPtrを増加
        pd += incD;                             // ＤのPtrを増加
    }                                           //
}

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

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

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

void            Support::up_movb2l_inc(
    BYTE        *ps,                            // 転送元へのポインタ
    long        *pd,                            // 転送先へのポインタ
    int         l,                              // 転送する数量
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    int         c4;                             // ４を示す定数値

    c4 = 4;                                     // 定数４セット
    if( l >= c4 ){                              // ４単位以上なら
        l -= c4;                                // DownCuntを４単位
        do{                                     // 毎に進め４単位
            *pd = (long)*ps;                    // 毎に転送する
            ps += incS;                         // ＳのPtrを増加
            pd += incD;                         // ＤのPtrを増加
            *pd = (long)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (long)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (long)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= c4 ) > 0 );              //
        l += c4;                                // DownCuntを４単位戻
    }                                           // す
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (long)*ps;                        // 転送する
        ps += incS;                             // ＳのPtrを増加
        pd += incD;                             // ＤのPtrを増加
    }                                           //
}

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

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

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

void            Support::up_movb2l_inc(
    BYTE        *ps,                            // 転送元へのポインタ
    long        *pd,                            // 転送先へのポインタ
    int         l,                              // 転送する数量
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「BYTE*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_movb2l_inc()」の
【ローカル変数】説明

){
    int         c4;                             // ４を示す定数値

「int c4;」は、定数値「４を示す値」を格納する変数
です！
何故、初期値「int c4=4;」と記載せずにアルゴリズム中に
代入しているかと言うとコンパイラシステムに依っては、
私の意図した≪ＣＰＵの高速レジスターに割り当てる≫で
無く、モット実行速度に影響を及ぼす機械コードに変換
する場合が在り、この記述に落ち着いたのです！
勿論、名称先頭の「c」はコンスト定数の意味です！

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

    c4 = 4;                                     // 定数４セット
    if( l >= c4 ){                              // ４単位以上なら
        l -= c4;                                // DownCuntを４単位
        do{                                     // 毎に進め４単位
            *pd = (long)*ps;                    // 毎に転送する
            ps += incS;                         // ＳのPtrを増加
            pd += incD;                         // ＤのPtrを増加
            *pd = (long)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (long)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (long)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= c4 ) > 0 );              //
        l += c4;                                // DownCuntを４単位戻
    }                                           // す
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (long)*ps;                        // 転送する
        ps += incS;                             // ＳのPtrを増加
        pd += incD;                             // ＤのPtrを増加
    }                                           //
}

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

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

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

void            Support::up_movc2s_inc(
    char        *ps,                            // 転送元へのポインタ
    short       *pd,                            // 転送先へのポインタ
    int         l,                              // 転送する数量
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    int         c4;                             // ４を示す定数値

    c4 = 4;                                     // 定数４セット
    if( l >= c4 ){                              // ４単位以上なら
        l -= c4;                                // DownCuntを４単位
        do{                                     // 毎に進め４単位
            *pd = (short)*ps;                   // 毎に転送する
            ps += incS;                         // ＳのPtrを増加
            pd += incD;                         // ＤのPtrを増加
            *pd = (short)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (short)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (short)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= c4 ) > 0 );              //
        l += c4;                                // DownCuntを４単位戻
    }                                           // す
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (short)*ps;                       // 転送する
        ps += incS;                             // ＳのPtrを増加
        pd += incD;                             // ＤのPtrを増加
    }                                           //
}

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

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

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

void            Support::up_movc2s_inc(
    char        *ps,                            // 転送元へのポインタ
    short       *pd,                            // 転送先へのポインタ
    int         l,                              // 転送する数量
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「char*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_movc2s_inc()」の
【ローカル変数】説明

){
    int         c4;                             // ４を示す定数値

「int c4;」は、定数値「４を示す値」を格納する変数
です！
何故、
初期値「int c4=4;」と記載せずにアルゴリズム中に代入
しているかと言うとコンパイラシステムに依っては、
私の意図した≪ＣＰＵの高速レジスターに割り当てる≫で
無く、モット実行速度に影響を及ぼす機械コードに変換
する場合が在り、この記述に落ち着いたのです！
勿論、名称先頭の「c」はコンスト定数の意味です！

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

    c4 = 4;                                     // 定数４セット
    if( l >= c4 ){                              // ４単位以上なら
        l -= c4;                                // DownCuntを４単位
        do{                                     // 毎に進め４単位
            *pd = (short)*ps;                   // 毎に転送する
            ps += incS;                         // ＳのPtrを増加
            pd += incD;                         // ＤのPtrを増加
            *pd = (short)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (short)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (short)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= c4 ) > 0 );              //
        l += c4;                                // DownCuntを４単位戻
    }                                           // す
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (short)*ps;                       // 転送する
        ps += incS;                             // ＳのPtrを増加
        pd += incD;                             // ＤのPtrを増加
    }                                           //
}

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

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

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

void            Support::up_movc2l_inc(
    char        *ps,                            // 転送元へのポインタ
    long        *pd,                            // 転送先へのポインタ
    int         l,                              // 転送する数量
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    int         c4;                             // ４を示す定数値

    c4 = 4;                                     // 定数４セット
    if( l >= c4 ){                              // ４単位以上なら
        l -= c4;                                // DownCuntを４単位
        do{                                     // 毎に進め４単位
            *pd = (long)*ps;                    // 毎に転送する
            ps += incS;                         // ＳのPtrを増加
            pd += incD;                         // ＤのPtrを増加
            *pd = (long)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (long)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (long)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= c4 ) > 0 );              //
        l += c4;                                // DownCuntを４単位戻
    }                                           // す
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (long)*ps;                        // 転送する
        ps += incS;                             // ＳのPtrを増加
        pd += incD;                             // ＤのPtrを増加
    }                                           //
}

（３－４－５６－Ａ）関数名「up_movc2l_inc」の説明

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

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

void            Support::up_movc2l_inc(
    char        *ps,                            // 転送元へのポインタ
    long        *pd,                            // 転送先へのポインタ
    int         l,                              // 転送する数量
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「char*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_movc2l_inc()」の
【ローカル変数】説明

){
    int         c4;                             // ４を示す定数値

「int c4;」は、定数値「４を示す値」を格納する変数
です！
何故、初期値「int c4=4;」と記載せずにアルゴリズム中に
代入しているかと言うとコンパイラシステムに依っては、
私の意図した≪ＣＰＵの高速レジスターに割り当てる≫で
無く、モット実行速度に影響を及ぼす機械コードに変換
する場合が在り、この記述に落ち着いたのです！
勿論、名称先頭の「c」はコンスト定数の意味です！

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

    c4 = 4;                                     // 定数４セット
    if( l >= c4 ){                              // ４単位以上なら
        l -= c4;                                // DownCuntを４単位
        do{                                     // 毎に進め４単位
            *pd = (long)*ps;                    // 毎に転送する
            ps += incS;                         // ＳのPtrを増加
            pd += incD;                         // ＤのPtrを増加
            *pd = (long)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (long)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (long)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= c4 ) > 0 );              //
        l += c4;                                // DownCuntを４単位戻
    }                                           // す
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (long)*ps;                        // 転送する
        ps += incS;                             // ＳのPtrを増加
        pd += incD;                             // ＤのPtrを増加
    }                                           //
}

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

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

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

void            Support::up_movs2b_inc(
    short       *ps,                            // 転送元へのポインタ
    BYTE        *pd,                            // 転送先へのポインタ
    int         l,                              // 転送する数量
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    int         c4;                             // ４を示す定数値

    c4 = 4;                                     // 定数４セット
    if( l >= c4 ){                              // ４単位以上なら
        l -= c4;                                // DownCuntを４単位
        do{                                     // 毎に進め４単位
            *pd = (BYTE)*ps;                    // 毎に転送する
            ps += incS;                         // ＳのPtrを増加
            pd += incD;                         // ＤのPtrを増加
            *pd = (BYTE)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (BYTE)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (BYTE)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= c4 ) > 0 );              //
        l += c4;                                // DownCuntを４単位戻
    }                                           // す
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (BYTE)*ps;                        // 転送する
        ps += incS;                             // ＳのPtrを増加
        pd += incD;                             // ＤのPtrを増加
    }                                           //
}

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

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

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

void            Support::up_movs2b_inc(
    short       *ps,                            // 転送元へのポインタ
    BYTE        *pd,                            // 転送先へのポインタ
    int         l,                              // 転送する数量
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「short*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_movs2b_inc()」の
【ローカル変数】説明

){
    int         c4;                             // ４を示す定数値

「int c4;」は、定数値「４を示す値」を格納する変数で
す！何故、初期値「int c4=4;」と記載せずにアルゴリズム
中に代入しているかと言うとコンパイラシステムに依っては
私の意図した≪ＣＰＵの高速レジスターに割り当てる≫で
無く、モット実行速度に影響を及ぼす機械コードに変換する
場合が在り、この記述に落ち着いたのです！
勿論、名称先頭の「c」はコンスト定数の意味です！

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

    c4 = 4;                                     // 定数４セット
    if( l >= c4 ){                              // ４単位以上なら
        l -= c4;                                // DownCuntを４単位
        do{                                     // 毎に進め４単位
            *pd = (BYTE)*ps;                    // 毎に転送する
            ps += incS;                         // ＳのPtrを増加
            pd += incD;                         // ＤのPtrを増加
            *pd = (BYTE)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (BYTE)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (BYTE)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= c4 ) > 0 );              //
        l += c4;                                // DownCuntを４単位戻
    }                                           // す
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (BYTE)*ps;                        // 転送する
        ps += incS;                             // ＳのPtrを増加
        pd += incD;                             // ＤのPtrを増加
    }                                           //
}

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

（３－４－５８）関数「void up_movs2c_inc(
short*ps,char*pd,int l,int incS,int incD);」の説明

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

void            Support::up_movs2c_inc(
    short       *ps,                            // 転送元へのポインタ
    char        *pd,                            // 転送先へのポインタ
    int         l,                              // 転送する数量
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    int         c4;                             // ４を示す定数値

    c4 = 4;                                     // 定数４セット
    if( l >= c4 ){                              // ４単位以上なら
        l -= c4;                                // DownCuntを４単位
        do{                                     // 毎に進め４単位
            *pd = (char)*ps;                    // 毎に転送する
            ps += incS;                         // ＳのPtrを増加
            pd += incD;                         // ＤのPtrを増加
            *pd = (char)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (char)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (char)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= c4 ) > 0 );              //
        l += c4;                                // DownCuntを４単位戻
    }                                           // す
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (char)*ps;                        // 転送する
        ps += incS;                             // ＳのPtrを増加
        pd += incD;                             // ＤのPtrを増加
    }                                           //
}

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

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

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

void            Support::up_movs2c_inc(
    short       *ps,                            // 転送元へのポインタ
    char        *pd,                            // 転送先へのポインタ
    int         l,                              // 転送する数量
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「short*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「char*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_movs2c_inc()」の
【ローカル変数】説明

){
    int         c4;                             // ４を示す定数値

「int c4;」は、定数値「４を示す値」を格納する変数で
す！何故、初期値「int c4=4;」と記載せずにアルゴリズム
中に代入しているかと言うとコンパイラシステムに依って
は、私の意図した≪ＣＰＵの高速レジスターに割り当てる≫
で無く、モット実行速度に影響を及ぼす機械コードに変換
する場合が在り、この記述に落ち着いたのです！
勿論、名称先頭の「c」はコンスト定数の意味です！

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

    c4 = 4;                                     // 定数４セット
    if( l >= c4 ){                              // ４単位以上なら
        l -= c4;                                // DownCuntを４単位
        do{                                     // 毎に進め４単位
            *pd = (char)*ps;                    // 毎に転送する
            ps += incS;                         // ＳのPtrを増加
            pd += incD;                         // ＤのPtrを増加
            *pd = (char)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (char)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (char)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= c4 ) > 0 );              //
        l += c4;                                // DownCuntを４単位戻
    }                                           // す
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (char)*ps;                        // 転送する
        ps += incS;                             // ＳのPtrを増加
        pd += incD;                             // ＤのPtrを増加
    }                                           //
}

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

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

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

void            Support::up_movs2l_inc(
    short       *ps,                            // 転送元へのポインタ
    long        *pd,                            // 転送先へのポインタ
    int         l,                              // 転送する数量
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    int         c4;                             // ４を示す定数値

    c4 = 4;                                     // 定数４セット
    if( l >= c4 ){                              // ４単位以上なら
        l -= c4;                                // DownCuntを４単位
        do{                                     // 毎に進め４単位
            *pd = (long)*ps;                    // 毎に転送する
            ps += incS;                         // ＳのPtrを増加
            pd += incD;                         // ＤのPtrを増加
            *pd = (long)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (long)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (long)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= c4 ) > 0 );              //
        l += c4;                                // DownCuntを４単位戻
    }                                           // す
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (long)*ps;                        // 転送する
        ps += incS;                             // ＳのPtrを増加
        pd += incD;                             // ＤのPtrを増加
    }                                           //
}

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

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

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

void            Support::up_movs2l_inc(
    short       *ps,                            // 転送元へのポインタ
    long        *pd,                            // 転送先へのポインタ
    int         l,                              // 転送する数量
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「short*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_movs2l_inc()」の
【ローカル変数】説明

){
    int         c4;                             // ４を示す定数値

「int c4;」は、定数値「４を示す値」を格納する変数
です！何故、初期値「int c4=4;」と記載せずに
アルゴリズム中に代入しているかと言うとコンパイラシス
テムに依っては、私の意図した≪ＣＰＵの高速レジスターに
割り当てる≫で無く、モット実行速度に影響を及ぼす機械
コードに変換する場合が在り、この記述に落ち着いた
のです！
勿論、名称先頭の「c」はコンスト定数の意味です！

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

    c4 = 4;                                     // 定数４セット
    if( l >= c4 ){                              // ４単位以上なら
        l -= c4;                                // DownCuntを４単位
        do{                                     // 毎に進め４単位
            *pd = (long)*ps;                    // 毎に転送する
            ps += incS;                         // ＳのPtrを増加
            pd += incD;                         // ＤのPtrを増加
            *pd = (long)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (long)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (long)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= c4 ) > 0 );              //
        l += c4;                                // DownCuntを４単位戻
    }                                           // す
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (long)*ps;                        // 転送する
        ps += incS;                             // ＳのPtrを増加
        pd += incD;                             // ＤのPtrを増加
    }                                           //
}

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

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

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

void            Support::up_movl2b_inc(
    long        *ps,                            // 転送元へのポインタ
    BYTE        *pd,                            // 転送先へのポインタ
    int         l,                              // 転送する数量
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    int         c4;                             // ４を示す定数値

    c4 = 4;                                     // 定数４セット
    if( l >= c4 ){                              // ４単位以上なら
        l -= c4;                                // DownCuntを４単位
        do{                                     // 毎に進め４単位
            *pd = (BYTE)*ps;                    // 毎に転送する
            ps += incS;                         // ＳのPtrを増加
            pd += incD;                         // ＤのPtrを増加
            *pd = (BYTE)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (BYTE)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (BYTE)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= c4 ) > 0 );              //
        l += c4;                                // DownCuntを４単位戻
    }                                           // す
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (BYTE)*ps;                        // 転送する
        ps += incS;                             // ＳのPtrを増加
        pd += incD;                             // ＤのPtrを増加
    }                                           //
}

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

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

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

void            Support::up_movl2b_inc(
    long        *ps,                            // 転送元へのポインタ
    BYTE        *pd,                            // 転送先へのポインタ
    int         l,                              // 転送する数量
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「long*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_movl2b_inc()」の
【ローカル変数】説明

){
    int         c4;                             // ４を示す定数値

「int c4;」は、定数値「４を示す値」を格納する変数で
す！何故、初期値「int c4=4;」と記載せずにアルゴリズム
中に代入しているかと言うとコンパイラシステムに依っては
私の意図した≪ＣＰＵの高速レジスターに割り当てる≫で
無く、モット実行速度に影響を及ぼす機械コードに変換する
場合が在り、この記述に落ち着いたのです！
勿論、名称先頭の「c」はコンスト定数の意味です！

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

    c4 = 4;                                     // 定数４セット
    if( l >= c4 ){                              // ４単位以上なら
        l -= c4;                                // DownCuntを４単位
        do{                                     // 毎に進め４単位
            *pd = (BYTE)*ps;                    // 毎に転送する
            ps += incS;                         // ＳのPtrを増加
            pd += incD;                         // ＤのPtrを増加
            *pd = (BYTE)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (BYTE)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (BYTE)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= c4 ) > 0 );              //
        l += c4;                                // DownCuntを４単位戻
    }                                           // す
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (BYTE)*ps;                        // 転送する
        ps += incS;                             // ＳのPtrを増加
        pd += incD;                             // ＤのPtrを増加
    }                                           //
}

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

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

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

void            Support::up_movl2c_inc(
    long        *ps,                            // 転送元へのポインタ
    char        *pd,                            // 転送先へのポインタ
    int         l,                              // 転送する数量
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    int         c4;                             // ４を示す定数値

    c4 = 4;                                     // 定数４セット
    if( l >= c4 ){                              // ４単位以上なら
        l -= c4;                                // DownCuntを４単位
        do{                                     // 毎に進め４単位
            *pd = (char)*ps;                    // 毎に転送する
            ps += incS;                         // ＳのPtrを増加
            pd += incD;                         // ＤのPtrを増加
            *pd = (char)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (char)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (char)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= c4 ) > 0 );              //
        l += c4;                                // DownCuntを４単位戻
    }                                           // す
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (char)*ps;                        // 転送する
        ps += incS;                             // ＳのPtrを増加
        pd += incD;                             // ＤのPtrを増加
    }                                           //
}

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

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

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

void            Support::up_movl2c_inc(
    long        *ps,                            // 転送元へのポインタ
    char        *pd,                            // 転送先へのポインタ
    int         l,                              // 転送する数量
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「long*ps,」は、「source to destination」と元から
先（宛先）へコピーする元のデータポインタです！
「char*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_movl2c_inc()」の
【ローカル変数】説明

){
    int         c4;                             // ４を示す定数値

「int c4;」は、定数値「４を示す値」を格納する変数で
す！何故、初期値「int c4=4;」と記載せずにアルゴリズム
中に代入しているかと言うとコンパイラシステムに依っては
私の意図した≪ＣＰＵの高速レジスターに割り当てる≫で
無く、モット実行速度に影響を及ぼす機械コードに変換
する場合が在り、この記述に落ち着いたのです！
勿論、名称先頭の「c」はコンスト定数の意味です！

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

    c4 = 4;                                     // 定数４セット
    if( l >= c4 ){                              // ４単位以上なら
        l -= c4;                                // DownCuntを４単位
        do{                                     // 毎に進め４単位
            *pd = (char)*ps;                    // 毎に転送する
            ps += incS;                         // ＳのPtrを増加
            pd += incD;                         // ＤのPtrを増加
            *pd = (char)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (char)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (char)*ps;                    //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= c4 ) > 0 );              //
        l += c4;                                // DownCuntを４単位戻
    }                                           // す
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (char)*ps;                        // 転送する
        ps += incS;                             // ＳのPtrを増加
        pd += incD;                             // ＤのPtrを増加
    }                                           //
}

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

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

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

void            Support::up_movl2s_inc(
    long        *ps,                            // 転送元へのポインタ
    short       *pd,                            // 転送先へのポインタ
    int         l,                              // 転送する数量
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){
    int         c4;                             // ４を示す定数値

    c4 = 4;                                     // 定数４セット
    if( l >= c4 ){                              // ４単位以上なら
        l -= c4;                                // DownCuntを４単位
        do{                                     // 毎に進め４単位
            *pd = (short)*ps;                   // 毎に転送する
            ps += incS;                         // ＳのPtrを増加
            pd += incD;                         // ＤのPtrを増加
            *pd = (short)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (short)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (short)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= c4 ) > 0 );              //
        l += c4;                                // DownCuntを４単位戻
    }                                           // す
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (short)*ps;                       // 転送する
        ps += incS;                             // ＳのPtrを増加
        pd += incD;                             // ＤのPtrを増加
    }                                           //
}

（３－４－６２－Ａ）関数名「up_movl2s_inc」の説明

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

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

void            Support::up_movl2s_inc(
    long        *ps,                            // 転送元へのポインタ
    short       *pd,                            // 転送先へのポインタ
    int         l,                              // 転送する数量
    int         incS,                           // 増分：転送元 
    int         incD                            // 増分：転送先 
){

「long*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_movl2s_inc()」の
【ローカル変数】説明

){
    int         c4;                             // ４を示す定数値

「int c4;」は、定数値「４を示す値」を格納する変数で
す！
何故、初期値「int c4=4;」と記載せずにアルゴリズム中に
代入しているかと言うとコンパイラシステムに依っては、
私の意図した≪ＣＰＵの高速レジスターに割り当てる≫で
無く、モット実行速度に影響を及ぼす機械コードに変換する
場合が在り、この記述に落ち着いたのです！
勿論、名称先頭の「c」はコンスト定数の意味です！

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

    c4 = 4;                                     // 定数４セット
    if( l >= c4 ){                              // ４単位以上なら
        l -= c4;                                // DownCuntを４単位
        do{                                     // 毎に進め４単位
            *pd = (short)*ps;                   // 毎に転送する
            ps += incS;                         // ＳのPtrを増加
            pd += incD;                         // ＤのPtrを増加
            *pd = (short)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (short)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
            *pd = (short)*ps;                   //
            ps += incS;                         //
            pd += incD;                         //
        }while( ( l -= c4 ) > 0 );              //
        l += c4;                                // DownCuntを４単位戻
    }                                           // す
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = (short)*ps;                       // 転送する
        ps += incS;                             // ＳのPtrを増加
        pd += incD;                             // ＤのPtrを増加
    }                                           //
}

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

☆☆注意☆☆
関数「up_fill（）」から関数「up_movl2s_inc()」までで
画像メモリへ整数型の数値データや他のポインタで示された
データを連続して書き込む関数に対して解説して見ました！
読んで頂いてお判りに成ると思いますが、単純な操作を
「自動車レースカーのエンジンをカリカリにチューンアップ
」する見たいに色々行って居る事≪勿論、生成される
アセンブラコードを確認して無駄を出来るだけ省き、
更にベンチマークテスト「数万回或いは数百万回有る程度の
書き込み量のデータ処理にした実関数呼び出し実行」の
結果を反映して居ます！≫
次から少し、何か行って居る処理に付いて
関数「up_sumb();」から関数「up_sumi();」と
合計計算を行う関数を解説して行きます！

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

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

２０２４年２月１５続講

（３－４－６３）関数「int up_sumb(BYTE*ps,int l);」の説明

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

int         Support::up_sumb(
    BYTE    *ps,                                // データへのポインタ
    int     l                                   // 合計する数量
){
    int     data;                               // 合計データ

    data = 0;                                   // 合計値０クリア
    if( l >= 4 ){                               // ４単位以上なら
        l -= 4;                                 // DownCuntを４単位進め
        do{                                     // ４単位毎に
            data += *ps++;                      // 合計する
            data += *ps++;                      //
            data += *ps++;                      //
            data += *ps++;                      //
        }while( ( l -= 4 ) > 0 );               //
        l += 4;                                 // DownCuntを４単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        data += *ps++;                          // 合計する
    }                                           //
    return( data );                             // 合計値を返す
}

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

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「sum」は、≪合計≫意味する英単語です！
詰り「ポインタBYTE*ps」と実引数のメモリ上データを
合計する物です！

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

int         Support::up_sumb(
    BYTE    *ps,                                // データへのポインタ
    int     l                                   // 合計する数量
){

「BYTE*ps,」は、ポインタ「BYTE*ps」と実引数のメモリ上
データを型「BYTE」と１バイト単位で符号なしデータを示し
ます！
「int l」は、合計するデータの長さです！

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

){
    int     data;                               // 合計データ

「int data;」は、関数内で合計値を演算する変数です！

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

    data = 0;                                   // 合計値０クリア
    if( l >= 4 ){                               // ４単位以上なら
        l -= 4;                                 // DownCuntを４単位進め
        do{                                     // ４単位毎に
            data += *ps++;                      // 合計する
            data += *ps++;                      //
            data += *ps++;                      //
            data += *ps++;                      //
        }while( ( l -= 4 ) > 0 );               //
        l += 4;                                 // DownCuntを４単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        data += *ps++;                          // 合計する
    }                                           //
    return( data );                             // 合計値を返す
}

「data=0;」は、合計値の初期化≪０クリア≫！
「if(l>=4){l-=4;do{・・ループ中身・・}
while((l-=4)>0);}」は、分岐条件「l>=4」と長さが
4以上在る場合は、先ず、「l-=4;」とコレから処理する長さ
４分処理するので一旦、４減算し
「do{・・ループ中身・・}while((l-=4)>0);」後置ループ
判断のループ中身≪「data += *ps++;」と１単位処理
【変数dataに累算】し４個連続で記述して４回分のループの
代わりに高速に動作させて居ます！
関数「up_fill()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して頂け
ると思います！≫を実行し、後置ループ判断
「while((l-=4)>0);」は、勿論「l-=4」と４減算し判断、
この分岐ブロック最後の「l+=4;」は、減算した値の補正
です！
「while(--l>=0){data += *ps++;}」は、本来、
この関数「up_sumb()」の基本的な処理部分と判るで
しょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！
☆注意☆関数「up_movl_inc()」の解説でローカル
変数「int c4;」を使用して定数値「４」の代わりにＣＰＵ
内の高速レジスターを使用しているのにこの
関数「up_sumb()」では使用シナイのかは、是非、
レジスター変数にしたい変数「int data;」を優先≪
特定ＣＰＵに対するコンパイラシステムがレジスターに割り
当てる場合、「int data;」は是非割り当てたいが、
変数「int c4;」は特に必要が無い程の出現頻度と考えた
からで、もし、レジスターに割り当てラレナイ様な
古過ぎるＣＰＵならば抑々不要で更に
解説『高速大容量の代表的処理が、画像処理』に記載した
様にキャッシュメモリが十分に搭載された最新のＣＰＵ
ならば、変数「int c4;」を使う処理は蛇足（処理速度的に
影響無し）の可能性も有る≫したからです！
「return(data);」は、関数の結果として合計の値を
返します！

（３－４－６４）関数「int up_sums(short*ps,int l);」の説明

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

int             Support::up_sums(
    short       *ps,                            // データへのポインタ
    int         l                               // 合計する数量
){
    int         data;                           // 合計データ

    data = 0;                                   // 合計値０クリア
    if( l >= 4 ){                               // ４単位以上なら
        l -= 4;                                 // DownCuntを４単位進め
        do{                                     // ４単位毎に
            data += *ps++;                      // 合計する
            data += *ps++;                      //
            data += *ps++;                      //
            data += *ps++;                      //
        }while( ( l -= 4 ) > 0 );               //
        l += 4;                                 // DownCuntを４単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        data += *ps++;                          // 合計する
    }                                           //
    return( data );                             // 合計値を返す
}

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

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「sum」は、≪合計≫意味する英単語です！
詰り「ポインタshort*ps」と実引数のメモリ上データを
合計する物です！
「s」は、型名「short」の略です？！
勿論、２バイト単位として扱います！

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

int             Support::up_sums(
    short       *ps,                            // データへのポインタ
    int         l                               // 合計する数量
){

「short*ps,」は、ポインタ「short*ps」と実引数の
メモリ上データを型「short」と２バイト単位で符号有り
データを示します！
「int l」は、合計するデータの長さです！

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

){
    int         data;                           // 合計データ

「int data;」は、関数内で合計値を演算する変数です！

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

    data = 0;                                   // 合計値０クリア
    if( l >= 4 ){                               // ４単位以上なら
        l -= 4;                                 // DownCuntを４単位進め
        do{                                     // ４単位毎に
            data += *ps++;                      // 合計する
            data += *ps++;                      //
            data += *ps++;                      //
            data += *ps++;                      //
        }while( ( l -= 4 ) > 0 );               //
        l += 4;                                 // DownCuntを４単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        data += *ps++;                          // 合計する
    }                                           //
    return( data );                             // 合計値を返す
}

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

（３－４－６５）関数「int up_sumus(UWORD*ps,int l);」の説明

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

int         Support::up_sumus(
    UWORD*  ps,                                 // データへのポインタ
    int     l                                   // 合計する数量
){
    int     data;                               // 合計データ

    data = 0;                                   // 合計値０クリア
    if( l >= 4 ){                               // ４単位以上なら
        l -= 4;                                 // DownCuntを４単位進め
        do{                                     // ４単位毎に
            data += *ps++;                      // 合計する
            data += *ps++;                      //
            data += *ps++;                      //
            data += *ps++;                      //
        }while( ( l -= 4 ) > 0 );               //
        l += 4;                                 // DownCuntを４単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        data += *ps++;                          // 合計する
    }                                           //
    return( data );                             // 合計値を返す
}

（３－４－６５－Ａ）関数名「up_sumus」の説明

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「sum」は、≪合計≫意味する英単語です！
詰り「ポインタUWORD*ps」と実引数のメモリ上データを
合計する物です！
「us」は、型名「unsigned short」の略です？！
勿論、２バイト単位として扱います！

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

int         Support::up_sumus(
    UWORD*  ps,                                 // データへのポインタ
    int     l                                   // 合計する数量
){

「UWORD*ps,」は、ポインタ「UWORD*ps」と実引数の
メモリ上データを型「UWORD」と２バイト単位で符号有り
データを示します！
「int l」は、合計するデータの長さです！

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

){
    int     data;                               // 合計データ

「int data;」は、関数内で合計値を演算する変数です！

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

    data = 0;                                   // 合計値０クリア
    if( l >= 4 ){                               // ４単位以上なら
        l -= 4;                                 // DownCuntを４単位進め
        do{                                     // ４単位毎に
            data += *ps++;                      // 合計する
            data += *ps++;                      //
            data += *ps++;                      //
            data += *ps++;                      //
        }while( ( l -= 4 ) > 0 );               //
        l += 4;                                 // DownCuntを４単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        data += *ps++;                          // 合計する
    }                                           //
    return( data );                             // 合計値を返す
}

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

（３－４－６６）関数「int up_suml(long*ps,int l);」の説明

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

int         Support::up_suml(
    long    *ps,                                // データへのポインタ
    int     l                                   // 合計する数量
){
    int     data;                               // 合計データ

    data = 0;                                   // 合計値０クリア
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCuntを８単位進め
        do{                                     // ８単位毎に
            data += *ps++;                      // 合計する
            data += *ps++;                      //
            data += *ps++;                      //
            data += *ps++;                      //
            data += *ps++;                      //
            data += *ps++;                      //
            data += *ps++;                      //
            data += *ps++;                      //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCuntを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        data += *ps++;                          // 合計する
    }                                           //
    return( data );                             // 合計値を返す
}

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

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「sum」は、≪合計≫意味する英単語です！
詰り「ポインタlong*ps」と実引数のメモリ上データを
合計する物です！
「l」は、型名「long」の略です？！
勿論、４バイト単位として扱います！

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

int         Support::up_suml(
    long    *ps,                                // データへのポインタ
    int     l                                   // 合計する数量
){

「long*ps,」は、ポインタ「long*ps」と実引数の
メモリ上データを型「long」と２バイト単位で符号有り
データを示します！
「int l」は、合計するデータの長さです！

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

){
    int     data;                               // 合計データ

「int data;」は、関数内で合計値を演算する変数です！

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

    data = 0;                                   // 合計値０クリア
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCuntを８単位進め
        do{                                     // ８単位毎に
            data += *ps++;                      // 合計する
            data += *ps++;                      //
            data += *ps++;                      //
            data += *ps++;                      //
            data += *ps++;                      //
            data += *ps++;                      //
            data += *ps++;                      //
            data += *ps++;                      //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCuntを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        data += *ps++;                          // 合計する
    }                                           //
    return( data );                             // 合計値を返す
}

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

（３－４－６７）関数「int up_sumi(int*ps,int l);」の説明

int         Support::up_sumi(
    int     *ps,                                // データへのポインタ
    int     l                                   // 合計する数量
){
    return( up_suml( (long*)ps, l ) );          // LONG型で処理
}

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

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

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「sum」は、≪合計≫意味する英単語です！
詰り「ポインタint*ps」と実引数のメモリ上データを合計
する物です！
「i」は、型名「int」の略です？！勿論、符号有りの
４バイト単位を意味します！

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

int         Support::up_sumi(
    int     *ps,                                // データへのポインタ
    int     l                                   // 合計する数量
){

「int*ps,」は、ポインタ「int*ps」と実引数のメモリ上
データを型「int」と４バイト単位で符号有りデータを示し
ます！
「int l」は、合計するデータの長さです！

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

int         Support::up_sumi(
    int     *ps,                                // データへのポインタ
    int     l                                   // 合計する数量
){
    return( up_suml( (long*)ps, l ) );          // LONG型で処理
}

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

（３－４－６８）関数「int up_mov_sumus(
UWORD*ps,UWORD*pd,int l);」の説明

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

int             Support::up_mov_sumus(
    UWORD       *ps,                            // Ｓデータへのポインタ
    UWORD       *pd,                            // Ｄデータへのポインタ
    int         l                               // 合計する数量
){
    int         d;                              // Ｓのデータ
    int         data;                           // 合計データ

    data = 0;                                   // 合計値０クリア
    if( l >= 2 ){                               // ２単位以上なら
        l -= 2;                                 // DownCuntを２単位進め
        do{                                     // ２単位毎に
            d     = *ps++;                      // Ｓデータを取り出し
            *pd++ = d;                          // Ｄへ転送し
            data += d;                          // 合計する
            d     = *ps++;                      //
            *pd++ = d;                          //
            data += d;                          //
        }while( ( l -= 2 ) > 0 );               //
        l += 2;                                 // DownCuntを２単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        d     = *ps++;                          // Ｓデータを取り出し
        *pd++ = d;                              // Ｄへ転送し
        data += d;                              // 合計する
    }                                           //
    return( data );                             // 合計値を返す
}

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

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「mov」は、「move」≪動かす、移す、移動させる≫意味
する英単語です！
詰り「source to destination」と元から先（宛先）へ移動
と言う依り、コピー動作を行う物です！
「sum」は、≪合計≫意味する英単語です！
詰りコピーしながら「ポインタUWORD*ps」と実引数の
メモリ上データを合計する物です！
「us」は、型名「unsigned short」の略です？！勿論、
２バイト単位として扱います！

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

int             Support::up_mov_sumus(
    UWORD       *ps,                            // Ｓデータへのポインタ
    UWORD       *pd,                            // Ｄデータへのポインタ
    int         l                               // 合計する数量
){

「UWORD*ps,」は、ポインタ「UWORD*ps」と実引数の
メモリ上データを型「UWORD」と２バイト単位で符号有りデータを示します！
「UWORD*pd,」は、ポインタ「UWORD*pd」で示す
実引数のメモリ上へデータを型「UWORD」と２バイト単位で符号無しデータとしてコピーします！
「int l」は、転送（コピー）＆合計処理するデータの
長さです！

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

    int         d;                              // Ｓのデータ
    int         data;                           // 合計データ

「int d;」は、仮引数「UWORD*ps,」のポインタで示される
データの一時置き場の変数です！
「int data;」は、関数内で合計値を演算する変数です！

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

    data = 0;                                   // 合計値０クリア
    if( l >= 2 ){                               // ２単位以上なら
        l -= 2;                                 // DownCuntを２単位進め
        do{                                     // ２単位毎に
            d     = *ps++;                      // Ｓデータを取り出し
            *pd++ = d;                          // Ｄへ転送し
            data += d;                          // 合計する
            d     = *ps++;                      //
            *pd++ = d;                          //
            data += d;                          //
        }while( ( l -= 2 ) > 0 );               //
        l += 2;                                 // DownCuntを２単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        d     = *ps++;                          // Ｓデータを取り出し
        *pd++ = d;                              // Ｄへ転送し
        data += d;                              // 合計する
    }                                           //
    return( data );                             // 合計値を返す
}

「data=0;」は、合計値の初期化≪０クリア≫！
「if(l>=2){l-=2;do{・・ループ中身・・}
while((l-=2)>0);}」は、分岐条件「l>=2」と長さが
2以上在る場合は、先ず、「l-=2;」とコレから処理する長さ
２分処理するので一旦、２減算し
「do{・・ループ中身・・}while((l-=2)>0);」後置ループ
判断のループ中身≪「d=*ps++;*pd++=d;data+=d;」と１単位
処理【変数dataに累算と共に】し
「source to destination」と元から先（宛先）へデータを
コピー２個連続で記述して２回分のループの代わりに高速に
動作させて居ます！
関数「up_fill()」の説明でも紹介した様に「ループ判断の
処理割合を減らし中身だけに特化」した事は、理解して頂け
ると思います！≫を実行し、後置ループ判断
「while((l-=2)>0);」は、勿論「l-=2」と２減算し判断、
この分岐ブロック最後の「l+=2;」は、減算した値の補正
です！
「while(--l>=0){d=*ps++;*pd++=d;data+=d;}」は、本来、
この関数「up_mov_sumus()」の基本的な処理部分と
判るでしょう？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！
「return(data);」は、関数の結果として合計の値を返しま
す！
☆注意☆他の繰り返し処理を高速化させる場合は、
１６回並べる関数「up_movb()」や８回並べる
関数「up_fill()」に比べて２回並べる
関数「up_mov_sumus()」は、少なく思えるでしょう！
これは、中身「d=*ps++;*pd++=d;data+=d;」が
ループ判定「while(--l>=0)」等に比べて重たい≪ＣＰＵの
処理時間が長い≫と考え、余りループ判定の割合が小さいと
考えたからです！
☆注意☆この関数「up_mov_sumus()」と「up_mov_sum系」の関数は、この関数「up_mov_sumus()」だけで他のデータの
組み合わせは用意していません！
この関数だけ、他のクラスで使用されているからで他は
不要として作成シナカッタからです！
最もソースコードで提供して居ますので幾らでも読者様は
追加して結構です！
但し、私のソースコードで無く成りますので私は動作保証
できませんがご了承ください！

★注意★次から、関数「up_fill_float()」と
関数「up_fill()系」と今まで講義を読んで頂いた読者様に
判る通り、関数「up_fill()系」に型「float」・
型「double」と実数型が出てきます！
何故、後ろの方に有るかは、作成過程の順番からで
最初ＡＤＳ社製画像処理装置に使用していたＣＰＵに
浮動小数点演算機能が無い物だったので後で
グレードアップした時に使えるように成ったので後付で
追加したからです！

（３－４－６９）関数「void up_fill_float(
int s,float*pd,int l);」の説明

ｃｏｄｅ

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

void        Support::up_fill_float(
    double  s,                                  // 書き込むデータ
    float*  pd,                                 // メモリ領域へのPtr
    int     l                                   // 書き込む大きさ
){
    float   ss;                                 // 書き込むデータ

    ss = (float)s;                              // double → short
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = ss;                         // データを書き込む
            *pd++ = ss;                         //
            *pd++ = ss;                         //
            *pd++ = ss;                         //
            *pd++ = ss;                         //
            *pd++ = ss;                         //
            *pd++ = ss;                         //
            *pd++ = ss;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = ss;                             // データを書き込む
    }                                           //
}

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

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「fill」は、穴埋めを意味する英単語です！
穴埋めと言う依り、埋め込む＝全て同じ値にする（
書き込む）との意味です！
今回は「_float」と単精度浮動小数点「float」型と
４バイト単位です！

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

void        Support::up_fill_float(
    double  s,                                  // 書き込むデータ
    float*  pd,                                 // メモリ領域へのPtr
    int     l                                   // 書き込む大きさ
){

「double s,」は、書き込むデータです！
「s」は、英単語「source」ソースで元とかの意味です！
☆注意☆「double」にしたのは、Ｃ言語では通常は、
倍精度浮動小数が、デフォルトの浮動小数演算単位だから
です！
「float *pd,」は、対応する実引数を示す書き込み
ポインタです！
「d」は「destination」行き先（宛先）です。
詰り「source to destination」とデータの向きを示しま
す！
勿論、「float型」なので３２ビット（４バイト）サイズ
です！
「int l」は、書き込む長さです！

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

){
    float   ss;                                 // 書き込むデータ

仮引数「double s,」は、Ｃ言語では通常は倍精度浮動小数
が、デフォルトの浮動小数演算単位だからですが、
ソノママ「*pd++=s;」では、書き込むたびに型変換が
起こるＣＰＵに＆処理系が存在するので書き込む「*pd」の
型と同じ型の変数にする為の小細工用です！

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

    ss = (float)s;                              // double → short
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = ss;                         // データを書き込む
            *pd++ = ss;                         //
            *pd++ = ss;                         //
            *pd++ = ss;                         //
            *pd++ = ss;                         //
            *pd++ = ss;                         //
            *pd++ = ss;                         //
            *pd++ = ss;                         //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = ss;                             // データを書き込む
    }                                           //

「ss = (float)s;」は、仮引数「double s,」から
float型の「*pd」へ書き込む為に型変換が起こり難い
内部変数に一旦、置いた事です！
「if(l>=8){・・分岐中身・・}」は、条件「l>=8」を
満足（詰り書き込む長さが８以上と十分有る場合の
高速動作用）が中身です！
そして分岐中身は
「l-=8;do{・・ループ中身・・}while((l-=8)>0);」と
「do{中身}while後置ループ条件;」でループ中身は、
「*pd++=ss;*pd++=ss;*pd++=ss;*pd++=ss;*pd++=ss;
*pd++=ss;*pd++=ss;*pd++=ss;」と「*pd++=ss;」と
１単位書き込んで１単位ポインタを進を８個並べて処理し
ます（詰り、８単位毎処理）！
そして後置ループ条件「(l-=8)>0」と「(l-=8)」と
長さ「ｌ」を８減らした数が
0より大きいと、８単位処理した事を長さにも反映した後で
ループ判定します！
☆注意☆この様にするのは、
解説『高速大容量の代表的処理が、画像処理』で説明した
様に実際に必要な「*pd++=ss;」の処理はＣＰＵ内の処理は
変わら無いが、ループ回数を制御する処理は１／８に
単純計算減らせるからです！
「l+=8;」は、後置ループ条件の中で「l-=8」と
長さ「ｌ」を８減らす操作をしている為にループの直後に
補正を入れる必要が有ったからです！
if(l>=8){・・分岐中身・・}」を終えると
「while(--l>=0){*pd++=ss;}」と本来は、この記述だけで
関数「up_fill_float()」は記述出来るのですが、
ココでは長さ「l」が、８未満の処理と８単位毎の処理で
細かく対処出来無かった部分が処理されます！

（３－４－７０）関数「void up_fill_double(
int s,double*pd,int l);」の説明

void        Support::up_fill_double(
    double  s,                                  // 書き込むデータ
    double* pd,                                 // メモリ領域へのPtr
    int     l                                   // 書き込む大きさ
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = s;                          // データを書き込む
            *pd++ = s;                          //
            *pd++ = s;                          //
            *pd++ = s;                          //
            *pd++ = s;                          //
            *pd++ = s;                          //
            *pd++ = s;                          //
            *pd++ = s;                          //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = s;                              // データを書き込む
    }                                           //
}

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

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

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「fill」は、穴埋めを意味する英単語です！
穴埋めと言う依り、埋め込む＝全て同じ値にする（書き込む
）との意味です！
今回は「_double」と倍精度浮動小数点「double」型と
８バイト単位です！

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

void        Support::up_fill_double(
    double  s,                                  // 書き込むデータ
    double* pd,                                 // メモリ領域へのPtr
    int     l                                   // 書き込む大きさ
){

「double s,」は、書き込むデータです！
「s」は、英単語「source」ソースで元とかの意味です！
「double *pd,」は、対応する実引数を示す書き込み
ポインタです！
「d」は「destination」行き先です。
詰り「source to destination」とデータの向きを示しま
す！
勿論、「double型」なので６４ビット（８バイト）サイズ
です！
「int l」は、書き込む長さです！

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

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd++ = s;                          // データを書き込む
            *pd++ = s;                          //
            *pd++ = s;                          //
            *pd++ = s;                          //
            *pd++ = s;                          //
            *pd++ = s;                          //
            *pd++ = s;                          //
            *pd++ = s;                          //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd++ = s;                              // データを書き込む
    }                                           //
}

「if(l>=8){・・分岐中身・・}」は、条件「l>=8」を
満足（詰り書き込む長さが８以上と十分有る場合の
高速動作用）が中身です！
そして分岐中身は
「l-=8;do{・・ループ中身・・}while((l-=8)>0);」と
「do{中身}while後置ループ条件;」でループ中身は、
「*pd++=s:*pd++=s:*pd++=s:*pd++=s:*pd++=s:*pd++=s:
*pd++=s:*pd++=s:」と「*pd++=s:」と１単位書き込んで
１単位ポインタを進を８個並べて処理します（詰り、
８単位毎処理）！
そして後置ループ条件「(l-=8)>0」と「(l-=8)」と
長さ「ｌ」を８減らした数が0より大きいと、８単位処理
した事を長さにも反映した後でループ判定します！
☆注意☆この様にするのは、
解説『高速大容量の代表的処理が、画像処理』で説明した
様に実際に必要な「*pd++=s:」の処理はＣＰＵ内の処理は
変わら無いが、ループ回数を制御する処理は１／８に
単純計算減らせるからです！
「l+=8;」は、後置ループ条件の中で「l-=8」と
長さ「ｌ」を８減らす操作をしている為にループの直後に
補正を入れる必要が有ったからです！
if(l>=8){・・分岐中身・・}」を終えると
「while(--l>=0){*pd++=s:}」と本来は、この記述だけで
関数「up_fill_double()」は記述出来るのですが、
ココでは長さ「l」が、８未満の処理と８単位毎の処理で
細かく対処出来無かった部分が処理されます！

（３－４－７１）関数「void up_fill_inc_float(
int s,float*pd,int l,int inc);」の説明

void        Support::up_fill_inc_float(
    double  s,                                  // 書き込むデータ
    float*  pd,                                 // メモリ領域へのPtr
    int     l,                                  // 書き込む大きさ
    int     inc                                 // 増分
){
    float   ss;                                 // 書き込むデータ

    ss = (float)s;                              // double → short
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = ss;                           // データを書き込む
            pd += inc;                          // （Ptrを増分進める）
            *pd = ss;                           //
            pd += inc;                          //
            *pd = ss;                           //
            pd += inc;                          //
            *pd = ss;                           //
            pd += inc;                          //
            *pd = ss;                           //
            pd += inc;                          //
            *pd = ss;                           //
            pd += inc;                          //
            *pd = ss;                           //
            pd += inc;                          //
            *pd = ss;                           //
            pd += inc;                          //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = ss;                               // データを書き込む
        pd += inc;                              // （Ptrを増分進める）
    }                                           //
}

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

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

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「fill」は、穴埋めを意味する英単語です！
穴埋めと言う依り、埋め込む＝全て同じ値にする（書き込む
）との意味です！
今回は「_float」と単精度浮動小数点「float」型と
４バイト単位です！
「inc」は、インクリメント 【ｉｎｃｒｅｍｅｎｔ】の
省略（ｉｎｃ）で任意の増加幅を設定出来る事が特徴です！

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

void        Support::up_fill_inc_float(
    double  s,                                  // 書き込むデータ
    float*  pd,                                 // メモリ領域へのPtr
    int     l,                                  // 書き込む大きさ
    int     inc                                 // 増分
){

「double s,」は、書き込むデータです！
「s」は、英単語「source」ソースで元とかの意味です！
☆注意☆「double」にしたのは、Ｃ言語では通常は
倍精度浮動小数が、デフォルトの浮動小数演算単位だから
です！
「float *pd,」は、対応する実引数を示す書き込み
ポインタです！
「d」は「destination」行き先（宛先）です。
詰り「source to destination」とデータの向きを示し
ます！
勿論、「float型」なので３２ビット（４バイト）サイズ
です！
「int l」は、書き込む長さです！
「int inc」は、こｎ関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_fill()系」では「inc＝1」と
成って居ると同等です！

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

){
    float   ss;                                 // 書き込むデータ

仮引数「double s,」は、Ｃ言語では通常は倍精度浮動小数
が、デフォルトの浮動小数演算単位だからですが、
ソノママ「*pd++=s;」では、書き込むたびに型変換が起こる
ＣＰＵに＆処理系が存在するので書き込む「*pd」の型と
同じ型の変数にする為の小細工用です！

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

    ss = (float)s;                              // double → short
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = ss;                           // データを書き込む
            pd += inc;                          // （Ptrを増分進める）
            *pd = ss;                           //
            pd += inc;                          //
            *pd = ss;                           //
            pd += inc;                          //
            *pd = ss;                           //
            pd += inc;                          //
            *pd = ss;                           //
            pd += inc;                          //
            *pd = ss;                           //
            pd += inc;                          //
            *pd = ss;                           //
            pd += inc;                          //
            *pd = ss;                           //
            pd += inc;                          //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = ss;                               // データを書き込む
        pd += inc;                              // （Ptrを増分進める）
    }                                           //
}

「ss = (float)s;」は、仮引数「double s,」から
float型の「*pd」へ書き込む為に型変換が起こり難い
内部変数に一旦、置いた事です！
「if(l>=8){・・分岐中身・・}」は、条件「l>=8」を
満足（詰り書き込む長さが８以上と十分有る場合の
高速動作用）が中身です！
そして分岐中身は
「l-=8;do{・・ループ中身・・}while((l-=8)>0);」と
「do{中身}while後置ループ条件;」でループ中身は、
「*pd=ss;pd+=inc;*pd=ss;pd+=inc;*pd=ss;pd+=inc;
*pd=ss;pd+=inc;*pd=ss;pd+=inc;*pd=ss;pd+=inc;*pd=ss;
pd+=inc;*pd=ss;pd+=inc;」と「*pd=ss;pd+=inc;」と
１単位書き込んで１単位ポインタを進を８個並べて処理し
ます（詰り、８単位毎処理）！
そして後置ループ条件「(l-=8)>0」と「(l-=8)」と
長さ「ｌ」を８減らした数が0より大きいと、８単位処理
した事を長さにも反映した後でループ判定します！
☆注意☆この様にするのは、
解説『高速大容量の代表的処理が、画像処理』で説明した
様に実際に必要な「*pd=ss;pd+=inc;」の処理はＣＰＵ内の
処理は変わら無いが、ループ回数を制御する処理は１／８に
単純計算減らせるからです！
「l+=8;」は、後置ループ条件の中で「l-=8」と長さ「ｌ」
を８減らす操作をしている為にループの直後に補正を入れる
必要が有ったからです！
if(l>=8){・・分岐中身・・}」を終えると
「while(--l>=0){*pd=ss;pd+=inc;}」と本来は、
この記述だけで関数「up_fill_inc_float()」は記述出来る
のですが、ココでは長さ「l」が、８未満の処理と
８単位毎の処理で細かく対処出来無かった部分が処理され
ます！

（３－４－７２）関数「void up_fill_inc_double(
int s,double*pd,int l,int inc);」の説明

void            Support::up_fill_inc_double(
    double      s,                              // 書き込むデータ
    double*     pd,                             // メモリ領域へのPtr
    int         l,                              // 書き込む大きさ
    int         inc                             // 増分
){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = s;                            // データを書き込む
            pd += inc;                          // （Ptrを増分進める）
            *pd = s;                            //
            pd += inc;                          //
            *pd = s;                            //
            pd += inc;                          //
            *pd = s;                            //
            pd += inc;                          //
            *pd = s;                            //
            pd += inc;                          //
            *pd = s;                            //
            pd += inc;                          //
            *pd = s;                            //
            pd += inc;                          //
            *pd = s;                            //
            pd += inc;                          //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = s;                                // データを書き込む
        pd += inc;                              // （Ptrを増分進める）
    }                                           //
}

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

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

「up_」は、元々、Ｃ言語でＡＤＳ社画像処理装置用の
関数をグローバル大域関数として「高速動作用汎用関数」
としての接頭語として付けた物です！
クラス構造にした画像処理ライブラリでは、
根本のクラス「Support」で使用したので大域関数と同じ
意味を持ちます！
「fill」は、穴埋めを意味する英単語です！
穴埋めと言う依り、埋め込む＝全て同じ値にする（書き込む
）との意味です！
今回は「_double」と倍精度浮動小数点「double」型と
８バイト単位です！
「inc」は、インクリメント 【ｉｎｃｒｅｍｅｎｔ】の
省略（ｉｎｃ）で任意の増加幅を設定出来る事が特徴です！

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

void            Support::up_fill_inc_double(
    double      s,                              // 書き込むデータ
    double*     pd,                             // メモリ領域へのPtr
    int         l,                              // 書き込む大きさ
    int         inc                             // 増分
){

「double s,」は、書き込むデータです！
「s」は、英単語「source」ソースで元とかの意味です！
「double *pd,」は、対応する実引数を示す書き込み
ポインタです！
「d」は「destination」行き先です。
詰り「source to destination」とデータの向きを示しま
す！
勿論、「double型」なので６４ビット（８バイト）サイズ
です！
「int l」は、書き込む長さです！
「int inc」は、こｎ関数「_inc」特徴の増分です！
「_inc」が付かない関数「up_fill()系」では「inc＝1」と
成って居ると同等です！

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

){
    if( l >= 8 ){                               // ８単位以上なら
        l -= 8;                                 // DownCountを８単位進め
        do{                                     // ８単位毎に
            *pd = s;                            // データを書き込む
            pd += inc;                          // （Ptrを増分進める）
            *pd = s;                            //
            pd += inc;                          //
            *pd = s;                            //
            pd += inc;                          //
            *pd = s;                            //
            pd += inc;                          //
            *pd = s;                            //
            pd += inc;                          //
            *pd = s;                            //
            pd += inc;                          //
            *pd = s;                            //
            pd += inc;                          //
            *pd = s;                            //
            pd += inc;                          //
        }while( ( l -= 8 ) > 0 );               //
        l += 8;                                 // DownCountを８単位戻す
    }                                           //
    while( --l >= 0 ){                          // 残りを１単位毎に
        *pd = s;                                // データを書き込む
        pd += inc;                              // （Ptrを増分進める）
    }                                           //
}

「if(l>=8){・・分岐中身・・}」は、条件「l>=8」を
満足（詰り書き込む長さが８以上と十分有る場合の
高速動作用）が中身です！
そして分岐中身は
「l-=8;do{・・ループ中身・・}while((l-=8)>0);」と
「do{中身}while後置ループ条件;」でループ中身は、
「*pd=s;pd+=inc;*pd=s;pd+=inc;*pd=s;pd+=inc;*pd=s;
pd+=inc;*pd=s;pd+=inc;*pd=s;pd+=inc;*pd=s;pd+=inc;
*pd=s;pd+=inc;」と「*pd=s;pd+=inc;」と１単位書き込んで
１単位ポインタを進を８個並べて処理します（詰り、
８単位毎処理）！
そして８個並べて処理します（詰り、８単位毎処理）！
そして後置ループ条件「(l-=8)>0」と「(l-=8)」と
長さ「ｌ」を８減らした数が0より大きいと、８単位処理
した事を長さにも反映した後でループ判定します！
☆注意☆この様にするのは、
解説『高速大容量の代表的処理が、画像処理』で説明した
様に実際に必要な「*pd=s;pd+=inc;」の処理はＣＰＵ内の
処理は変わら無いが、ループ回数を制御する処理は、
１／８に単純計算減らせるからです！
「l+=8;」は、後置ループ条件の中で「l-=8」と長さ「ｌ」
を８減らす操作をしている為にループの直後に補正を入れる
必要が有ったからです！
if(l>=8){・・分岐中身・・}」を終えると
「while(--l>=0){*pd=s;pd+=inc;}」と本来は、
この記述だけで関数「up_fill_inc_double()」は記述出来
るのですが、ココでは長さ「l」が、８未満の処理と
８単位毎の処理で細かく対処出来無かった部分が処理され
ます！

（３－４－７３）関数「void up_movd(
doubleps,doublepd,int l);」の説明

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

void        Support::up_movd(
    double  *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_movd」の説明

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

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

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

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

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

){
    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_movd()」の基本的な処理部分と判るでしょ
う？！
コレを処理長さ「l」が十分大きい時に小細工を施した事が
判るでしょう！

（３－４－７４）関数「void up_movf(
floatps,floatpd,int l);」の説明

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

void        Support::up_movf(
    float   *ps,                                // 転送元へのポインタ
    float   *pd,                                // 転送先へのポインタ
    int     l                                   // 転送する数量
){
    up_movl( (long*)ps, (long*)pd, l );         // ３２Bit単位転送
}

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

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

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

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

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

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

){
    up_movl( (long*)ps, (long*)pd, l );         // ３２Bit単位転送
}

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

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

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

文末