C++編【標準ライブラリ】　第３３章　valarray

C++11 で、以下のコンストラクタが追加されています。

valarray(valarray&& v);
valarray(std::initializer_list<T> lst);

valarray は一次元配列を模しているので、[]演算子を使って各要素にアクセスできます。有効範囲外のインデックスを指定すると、未定義な動作になります。

#include <iostream>
#include <valarray>

namespace {
    void PrintValarray(const std::valarray<double>& va)
    {
        std::cout.setf(std::ios_base::showpoint);

        const std::size_t size = va.size();
        for (std::size_t i = 0; i < size; ++i) {
            if (i >= 1) {
                std::cout << ", ";
            }
            std::cout << va[i];
        }
        std::cout << std::endl;
    }
}

int main()
{
    std::valarray<double> va(3);

    va[0] = 5.0;
    va[1] = 4.5;
    va[2] = -5.0;

    PrintValarray(va);
}

実行結果

5.00000, 4.50000, -5.00000

[]演算子は、サブセットを得る操作を行う際にも使用されます。これについては、「サブセット」の項で取り上げます。

以下の各種単項演算子を適用できます。

• +
• -
• ~
• !

valarray の全要素に対して、これらの演算子を適用し、結果の valarray を返します。

#include <iostream>
#include <valarray>

namespace {
    void PrintValarray(const std::valarray<double>& va)
    {
        std::cout.setf(std::ios_base::showpoint);

        const std::size_t size = va.size();
        for (std::size_t i = 0; i < size; ++i) {
            if (i >= 1) {
                std::cout << ", ";
            }
            std::cout << va[i];
        }
        std::cout << std::endl;
    }
}

int main()
{
    std::valarray<double> va(3);

    va[0] = 5.0;
    va[1] = 4.5;
    va[2] = -5.0;

    PrintValarray(-va);
}

実行結果

-5.00000, -4.50000, 5.00000

!演算子だけはやや特殊で、valarray の各要素に対して !演算子を適用した結果を、対応するインデックスに格納して返却します。そのため、!演算子の戻り値の型は valarray<bool> になります。

以下の各種二項演算子を適用できます。

• +
• -
• *
• /
• %
• &
• |
• ^
• <<
• >>

オペランドは、２つとも valarray にするか、一方を T型（T はテンプレート仮引数）の値にできます。

２つとも valarray にした場合は、互いの同じインデックスにある要素同士に対する演算になります。そのため、２つのオペランドを valarray にする場合は、両者の要素数が一致していないと未定義の動作になります。

一方を valarray、他方を T型の値にした場合は、valarray の全要素に対して、T型の値を使って演算子を適用します。例えば、va という要素数が 3 の int型の valarray に対して「va * 2」とすることは、「va[0] * 2, va[1] * 2, va[2] * 2」とすることに等しいです。ただし、計算の順番は保証されません。

なお、これらの二項演算子に対応する、複合代入演算子も使用できます。

#include <iostream>
#include <valarray>

namespace {
    void PrintValarray(const std::valarray<double>& va)
    {
        std::cout.setf(std::ios_base::showpoint);

        const std::size_t size = va.size();
        for (std::size_t i = 0; i < size; ++i) {
            if (i >= 1) {
                std::cout << ", ";
            }
            std::cout << va[i];
        }
        std::cout << std::endl;
    }
}

int main()
{
    std::valarray<double> va1(5.0, 3);
    std::valarray<double> va2(2.0, 3);

    PrintValarray(va1 + va2);
    PrintValarray(va1 * 3.0);

    va1 -= va2;
    PrintValarray(va1);

    va2 -= 0.5;
    PrintValarray(va2);
}

実行結果

7.00000, 7.00000, 7.00000
15.0000, 15.0000, 15.0000
3.00000, 3.00000, 3.00000
1.50000, 1.50000, 1.50000

以下の比較演算子、論理演算子を適用できます。

• ==
• !=
• <
• >
• <=
• >=
• &&
• ||

二項演算子の場合と同じく、２つのオペランドは、ともに要素数が同じ valarray か、他方に T型の値を与えるかのいずれかになります。前者の場合は、互いの同じインデックスにある要素同士に対する演算になります。後者の場合は、全要素に対して、T型の値を使って演算子を適用します。

いずれの演算子も、戻り値の型は valarray<bool> になります。つまり、各要素に対する演算子の適用結果を、対応するインデックスに格納して返却します。

#include <iostream>
#include <valarray>

namespace {
    void PrintValarray(const std::valarray<bool>& va)
    {
        std::cout.setf(std::ios_base::boolalpha);

        const std::size_t size = va.size();
        for (std::size_t i = 0; i < size; ++i) {
            if (i >= 1) {
                std::cout << ", ";
            }
            std::cout << va[i];
        }
        std::cout << std::endl;
    }
}

int main()
{
    std::valarray<double> va1(3);
    va1[0] = 3.0;
    va1[1] = 4.0;
    va1[2] = 5.0;

    std::valarray<double> va2(3.0, 3);

    PrintValarray(va1 == va2);
    PrintValarray(va1 != va2);
    PrintValarray(va1 > va2);

    PrintValarray(va1 == 5.0);
    PrintValarray(va1 != 5.0);
    PrintValarray(va1 > 5.0);
}

実行結果

true, false, false
false, true, true
false, true, true
false, false, true
true, true, false
false, false, false

これらの演算子が返す結果には不満を感じる場面があるかもしれません。例えば、２つの valarray の要素がすべて一致しているかどうかは、「va1 == va2」だけでは判定できず、返された valarray<bool> の要素がすべて true かどうかを調べる必要があります。そのため、補助関数を用意しておくと良いかもしれません。

#include <iostream>
#include <valarray>

namespace {
    bool IsAllTrue(const std::valarray<bool>& va)
    {
        const std::size_t size = va.size();
        for (std::size_t i = 0; i < size; ++i) {
            if (!va[i]) {
                return false;
            }
        }
        return true;
    }
}

int main()
{
    std::valarray<double> va1(3);
    va1[0] = 3.0;
    va1[1] = 4.0;
    va1[2] = 5.0;

    std::valarray<double> va2(3.0, 3);

    std::cout << std::boolalpha
              << IsAllTrue(va1 == va1) << "\n"
              << IsAllTrue(va1 == va2) << "\n"
              << IsAllTrue(va2 == 3.0) << std::endl;
}

実行結果

true
false
true

return std::all_of(std::cbegin(va), std::cend(va), [](bool b){return b;});

minメンバ関数は、すべての要素の中で、最小の値を返します。 maxメンバ関数は、すべての要素の中で、最大の値を返します。

T min() const;
T max() const;

いずれも、valarray が要素を１つも持っていない場合には、未定義の動作になることに注意してください。また、minメンバ関数は大小関係の比較のために T型 に対する <演算子を、maxメンバ関数は >演算子を用います。

sumメンバ関数は、すべての要素の値の合計を返します。

T sum() const;

valarray が要素を１つも持っていない場合には、未定義の動作になることに注意してください。また、合計値を求めるために、T型に対する +=演算子を使用しています。

shiftメンバ関数は、要素の位置を指定した個数分だけシフトさせます。

valarray<T> shift(int count) const;

引数 count の値が正数の場合は左シフト（配列の先頭に向かってシフト）になり、負数の場合は右シフト（配列の末尾に向かってシフト）になります。シフトした結果、空いた位置には、デフォルトコンストラクタによって初期化された新しい要素が作られます。

constメンバ関数であることから分かるように、対象の valarray自身は変化しません。シフトした後の新しい valarray が戻り値で返されるので、これを受け取る必要があります。

#include <iostream>
#include <valarray>

namespace {
    void PrintValarray(const std::valarray<double>& va)
    {
        std::cout.setf(std::ios_base::showpoint);

        const std::size_t size = va.size();
        for (std::size_t i = 0; i < size; ++i) {
            if (i >= 1) {
                std::cout << ", ";
            }
            std::cout << va[i];
        }
        std::cout << std::endl;
    }
}

int main()
{
    std::valarray<double> va(5);
    va[0] = 3.0;
    va[1] = 4.0;
    va[2] = 5.0;
    va[3] = 6.0;
    va[4] = 7.0;

    PrintValarray(va);

    va = va.shift(2);
    PrintValarray(va);

    va = va.shift(-1);
    PrintValarray(va);
}

実行結果

3.00000, 4.00000, 5.00000, 6.00000, 7.00000
5.00000, 6.00000, 7.00000, 0.000000, 0.000000
0.000000, 5.00000, 6.00000, 7.00000, 0.000000

cshiftメンバ関数は、要素の位置を指定した個数分だけ循環シフトさせます。

valarray<T> cshift(int count) const;

引数 count の値が正数の場合は左シフト（配列の先頭に向かってシフト）になり、負数の場合は右シフト（配列の末尾に向かってシフト）になります。循環シフトなので、シフトによって配列の範囲外へ飛び出していった要素は、逆側から戻ってきます。そのため、要素に空きが生まれることはありません。

constメンバ関数であることから分かるように、対象の valarray自身は変化しません。シフトした後の新しい valarray が戻り値で返されるので、これを受け取る必要があります。

#include <iostream>
#include <valarray>

namespace {
    void PrintValarray(const std::valarray<double>& va)
    {
        std::cout.setf(std::ios_base::showpoint);

        const std::size_t size = va.size();
        for (std::size_t i = 0; i < size; ++i) {
            if (i >= 1) {
                std::cout << ", ";
            }
            std::cout << va[i];
        }
        std::cout << std::endl;
    }
}

int main()
{
    std::valarray<double> va(5);
    va[0] = 3.0;
    va[1] = 4.0;
    va[2] = 5.0;
    va[3] = 6.0;
    va[4] = 7.0;

    PrintValarray(va);

    va = va.cshift(2);
    PrintValarray(va);

    va = va.cshift(-1);
    PrintValarray(va);
}

実行結果

3.00000, 4.00000, 5.00000, 6.00000, 7.00000
5.00000, 6.00000, 7.00000, 3.00000, 4.00000
4.00000, 5.00000, 6.00000, 7.00000, 3.00000

applyメンバ関数は、すべての要素に対して、指定の関数を適用します。

valarray<T> apply(T func(T)) const;
valarray<T> apply(T func(const T&)) const;

各要素を elem と表現すると、すべての要素に対して「func(elem)」を呼び出し、その結果を新しい valarray に格納します。最終的に、すべての結果を格納した valarray が戻り値で返されます。

#include <iostream>
#include <valarray>

namespace {
    void PrintValarray(const std::valarray<double>& va)
    {
        std::cout.setf(std::ios_base::showpoint);

        const std::size_t size = va.size();
        for (std::size_t i = 0; i < size; ++i) {
            if (i >= 1) {
                std::cout << ", ";
            }
            std::cout << va[i];
        }
        std::cout << std::endl;
    }
}

int main()
{
    std::valarray<double> va(5);
    va[0] = 3.7;
    va[1] = -1.9;
    va[2] = 2.5;
    va[3] = 0.6;
    va[4] = -4.0;

    PrintValarray(va.apply(std::floor));
    PrintValarray(va.apply(std::ceil));
    PrintValarray(va.apply(std::round));
}

実行結果

3.00000, -2.00000, 2.00000, 0.000000, -4.00000
4.00000, -1.00000, 3.00000, 1.00000, -4.00000
4.00000, -2.00000, 3.00000, 1.00000, -4.00000

要素の開始位置、個数、間隔（ストライド）という３つの指定によって、サブセットを得る方法をスライスと言います。これを行うには、std::sliceクラスと、[]演算子を使用します。

#include <iostream>
#include <valarray>

namespace {
    void PrintValarray(const std::valarray<double>& va)
    {
        std::cout.setf(std::ios_base::showpoint);

        const std::size_t size = va.size();
        for (std::size_t i = 0; i < size; ++i) {
            if (i >= 1) {
                std::cout << ", ";
            }
            std::cout << va[i];
        }
        std::cout << std::endl;
    }
}

int main()
{
    std::valarray<double> va1(5);
    std::valarray<double> va2(5);
    va1[0] = 0.0;
    va1[1] = 1.0;
    va1[2] = 2.0;
    va1[3] = 3.0;
    va1[4] = 4.0;
    va2[0] = 2.0;
    va2[1] = -1.0;
    va2[2] = -2.0;
    va2[3] = -1.0;
    va2[4] = 2.0;

    PrintValarray(va1[std::slice(0, 3, 2)]);
    PrintValarray(va1[std::slice(1, 2, 2)]);
    PrintValarray(va1[std::slice(4, 3, -2)]);

    va1[std::slice(0, 3, 2)] = 2.0;
    PrintValarray(va1);

    va1[std::slice(0, 3, 2)] *= va2[std::slice(0, 3, 2)];
    PrintValarray(va1);
}

実行結果

0.000000, 2.00000, 4.00000
1.00000, 3.00000
4.00000, 2.00000, 0.000000
2.00000, 1.00000, 2.00000, 3.00000, 2.00000
4.00000, 1.00000, -4.00000, 3.00000, 4.00000

std::slice の使い方が、関数呼び出しのように見えますが、これは一時オブジェクトを作って、コンストラクタに引数を渡しています。

第１引数が、サブセットに選び出す要素の開始インデックス、第２引数が、選び出す要素の個数、第３引数が、選び出す各要素間の距離です。これは負数にもできます。なお、こうして得られる対象要素のインデックスは、すべて有効なもので無ければなりません。有効でないインデックスを指定してしまうと、未定義の動作になります。

[]演算子は、std::slice型を受け取れるようにオーバーロードされており、スライスによってサブセットを定義するように処理が行われます。

std::valarray<T>    operator[](std::slice slicearr) const;
std::slice_array<T> operator[](std::slice slicearr);

非constメンバ関数の場合は、std::slice_arrayクラステンプレートが返されます。 これは、元の valarray への操作を行えるようにするための補助クラスです。主に代入系の演算子を使用でき、その演算は、元の valarray に対して行われます。

std::slice_array を経由して処理が行えない場合には、std::valarray へキャストしてください。std::valarray のコンストラクタには、std::slice_array を渡すタイプのものがあるので（「生成と初期化」の項参照）、static_cast を行うだけで変換できます。

スライスをより汎用的にした汎用スライスという方法があります。汎用スライスは、サブセットをｎ次元の形で得られます。「ｎ＝１」であれば、前述のスライスと同様なので、こちらの方が汎用的であるという訳です。

汎用スライスでは、std::gsliceクラスと []演算子を使用します。汎用スライスの場合には、要素の開始位置、個数、間隔（ストライド）という３つの指定のうち、個数と間隔を、配列で指定することが可能になっています。

#include <iostream>
#include <valarray>

namespace {
    void PrintValarray(const std::valarray<int>& va)
    {
        const std::size_t size = va.size();
        for (std::size_t i = 0; i < size; ++i) {
            if (i >= 1) {
                std::cout << ", ";
            }
            std::cout << va[i];
        }
        std::cout << std::endl;
    }
}

int main()
{
    std::valarray<int> va(25);
    for (std::size_t i = 0; i < va.size(); ++i) {
        va[i] = i;
    }

    std::size_t numsTable[] = {5, 2};
    std::size_t strideTable[] = {5, 1};
    std::valarray<std::size_t> num(numsTable, 2);
    std::valarray<std::size_t> stride(strideTable, 2);

    PrintValarray(va[std::gslice(1, num, stride)]);
}

実行結果

1, 2, 6, 7, 11, 12, 16, 17, 21, 22

最初に、5x5 の２次元配列をイメージして、valarray を定義し、ここから、5x2 の範囲の２次元配列を、サブセットとして得ようとしています。

スライスの場合と同じで、今度は std::gslice を []演算子のオペランドとして指定します。std::gslice の第２、第３引数は、valarray<std::size_t>型で指定します。

valarray<std::size_t>型で指定するために、valarray<std::size_t>型の変数を定義し、そこに渡す値のために、std::size_t型の配列を定義するという、かなり面倒なコードになっています。C++11以降であれば、valarray のコンストラクタに std::initializer_list を指定できるので、直接、「va[std::gslice(1, {5, 2}, {5, 1})]」のような記述が可能です。これなら煩わしくないし、見やすいですね。

[]演算子は、std::gslice型を受け取れるようにオーバーロードされており、汎用スライスによってサブセットを定義するように処理が行われます。

std::valarray<T>     operator[](std::gslice gslicearr) const;
std::gslice_array<T> operator[](std::gslice gslicearr);

非constメンバ関数の場合は、std::gslice_arrayクラステンプレートが返されます。これは、元の valarray への操作を行えるようにするための補助クラスです。主に代入系の演算子を使用でき、その演算は、元の valarray に対して行われます。

std::gslice_array を経由して処理が行えない場合には、std::valarray へキャストしてください。std::valarray のコンストラクタには、std::gslice_array を渡すタイプのものがあるので（「生成と初期化」の項参照）、static_cast を行うだけで変換できます。

マスクは、valarray<bool> を使って、サブセットを定義する方法です。true が入っている箇所に対応する要素だけが選び出されます。

#include <iostream>
#include <valarray>

namespace {
    void PrintValarray(const std::valarray<int>& va)
    {
        const std::size_t size = va.size();
        for (std::size_t i = 0; i < size; ++i) {
            if (i >= 1) {
                std::cout << ", ";
            }
            std::cout << va[i];
        }
        std::cout << std::endl;
    }
}

int main()
{
    std::valarray<int> va(25);
    for (std::size_t i = 0; i < va.size(); ++i) {
        va[i] = i;
    }

    PrintValarray(va[va < 10]);
    PrintValarray(va[va % 3 == 0]);
    PrintValarray(va[5 <= va && va <= 15]);
}

実行結果

0, 1, 2, 3, 4, 5, 6, 7, 8, 9
0, 3, 6, 9, 12, 15, 18, 21, 24
5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15

valarray<bool> は、valarray に対して比較演算子や論理演算子を適用すると得られる型と一致しています（「演算子」の項を参照）。そのため、「va[va < 10]」のような感じで記述できます。

[]演算子は、valarray<bool>型を受け取れるようにオーバーロードされており、マスクによってサブセットを定義するように処理が行われます。

std::valarray<T>   operator[](valarray<bool>& va) const;
std::mask_array<T> operator[](valarray<bool>& va);

非constメンバ関数の場合は、std::mask_arrayクラステンプレートが返されます。これは、元の valarray への操作を行えるようにするための補助クラスです。主に代入系の演算子を使用でき、その演算は、元の valarray に対して行われます。

std::mask_array を経由して処理が行えない場合には、std::valarray へキャストしてください。std::valarray のコンストラクタには、std::mask_array を渡すタイプのものがあるので（「生成と初期化」の項参照）、static_cast を行うだけで変換できます。

valarray<std::size_t> を使って、サブセットを定義する方法もあります。valarray<std::size_t> には、サブセットとして選び出したい要素のインデックスを格納しておきます。この方法は、最後に登場する indirect_array というクラステンプレートに倣って、間接的な指定と呼びます。

#include <iostream>
#include <valarray>

namespace {
    void PrintValarray(const std::valarray<int>& va)
    {
        const std::size_t size = va.size();
        for (std::size_t i = 0; i < size; ++i) {
            if (i >= 1) {
                std::cout << ", ";
            }
            std::cout << va[i];
        }
        std::cout << std::endl;
    }
}

int main()
{
    std::valarray<int> va(25);
    for (std::size_t i = 0; i < va.size(); ++i) {
        va[i] = i;
    }

    std::valarray<std::size_t> indexes(5);
    indexes[0] = 7;
    indexes[1] = 15;
    indexes[2] = 7;
    indexes[3] = 10;
    indexes[4] = 4;

    PrintValarray(va[indexes]);
}

実行結果

7, 15, 7, 10, 4

インデックスを格納した std::valarray<std::size_t> には、同じインデックスが含まれても構いませんし、大小関係がどういう順序で並んでいても構いません。ただし、無効なインデックスが入っていると、動作は未定義になります。

[]演算子は、valarray<std::size_t>型を受け取れるようにオーバーロードされており、間接的な指定によってサブセットを定義するように処理が行われます。

std::valarray<T>       operator[](valarray<std::size_t>& va) const;
std::indirect_array<T> operator[](valarray<std::size_t>& va);

非constメンバ関数の場合は、std::indirect_arrayクラステンプレートが返されます。これは、元の valarray への操作を行えるようにするための補助クラスです。主に代入系の演算子を使用でき、その演算は、元の valarray に対して行われます。

std::indirect_array を経由して処理が行えない場合には、std::valarray へキャストしてください。std::valarray のコンストラクタには、std::mask_array を渡すタイプのものがあるので（「生成と初期化」の項参照）、static_cast を行うだけで変換できます。