C# Vectorの使い方完全ガイド｜System.Numerics.Vectorで高速化する方法を初心者向けに解説

はじめに

C#で大量の数値データを処理していると、「for文で1つずつ計算している処理をもっと速くできないか」と考える場面があります。たとえば、配列同士の加算、画像の画素処理、音声データの変換、ゲームの座標計算、機械学習向けの前処理などでは、同じ計算を大量のデータに対して繰り返すことがよくあります。

このような処理を高速化する手段の1つが、System.Numerics.Vectorです。C#のVector<T>を使うと、CPUが対応している場合にSIMDによる並列計算を利用でき、通常のループより効率よく数値計算を実行できる可能性があります。Microsoftの公式ドキュメントでも、Vector<T>は並列アルゴリズムの低レベル最適化に適した数値ベクトル型として説明されています。Microsoft Learn

ただし、C#のVectorにはいくつか種類があります。Vector<T>、Vector2、Vector3、Vector4は名前が似ていますが、目的や使いどころが異なります。この記事では、C#のVectorの基礎から、System.Numerics.Vector<T>を使った高速化の方法、実践的なサンプルコード、注意点、よくあるエラーまで初心者向けにわかりやすく解説します。

1. C#のVectorとは？検索ユーザーが最初に知りたい基礎知識

1-1. C#におけるVectorの意味

C#におけるVectorとは、複数の数値をひとまとまりとして扱うための型です。一般的な配列が「たくさんの値を並べて保持するもの」だとすれば、Vectorは「複数の値をまとめて計算するための単位」と考えると理解しやすいです。

たとえば、通常の配列計算では次のように1要素ずつ処理します。

C#
for (int i = 0; i < a.Length; i++)
{
    result[i] = a[i] + b[i];
}

一方、Vector<T>を使うと、複数の要素をまとめて読み込み、まとめて加算できます。CPUや.NETランタイムが対応していれば、内部的にSIMD命令が使われ、複数データを並列に計算できます。

C#で「vector」と検索する人が知りたい内容は、大きく分けると次の2つです。

1つ目は、System.Numerics.Vector<T>を使った数値処理の高速化です。配列や数値データを効率よく処理したい場合はこちらが中心になります。

2つ目は、Vector2、Vector3、Vector4を使った座標や方向の表現です。ゲーム開発、3Dグラフィックス、物理計算などでよく使われます。

1-2. System.Numerics.Vectorとは

System.Numerics.Vectorは、.NETのSystem.Numerics名前空間に用意されている数値計算向けの型群です。代表的なものに、次のような型があります。

C#
using System.Numerics;

C#
Vector<int>
Vector<float>
Vector<double>
Vector2
Vector3
Vector4

このうち、Vector<T>はジェネリック型で、int、float、doubleなどの数値型をまとめて扱うために使います。Microsoftの公式ドキュメントでは、System.Numerics名前空間にはSIMDアクセラレーションに対応した型が含まれると説明されています。Microsoft Learn

Vector<T>の特徴は、1つのVectorインスタンスに入る要素数が固定ではなく、実行環境によって変わることです。たとえば、Vector<float>.Countが4になる環境もあれば、8になる環境もあります。これは、CPUのSIMDレジスタ幅や.NETランタイムの対応状況に依存するためです。

1-3. Vector<T>とVector2・Vector3・Vector4の違い

C#のVectorで混同しやすいのが、Vector<T>とVector2、Vector3、Vector4の違いです。

Vector<T>は、配列などの大量データをまとめて処理するための型です。要素数は環境によって変わり、主に高速化を目的として使います。

C#
Vector<float> values = new Vector<float>(1.0f);

一方、Vector2、Vector3、Vector4は、2次元、3次元、4次元のベクトルを表す固定サイズの型です。Microsoftの公式ドキュメントでも、Vector2は2つの単精度浮動小数点値、Vector3は3つの単精度浮動小数点値を表す型として説明されています。Microsoft Learn+1

C#
Vector2 position2D = new Vector2(10.0f, 20.0f);
Vector3 position3D = new Vector3(10.0f, 20.0f, 30.0f);
Vector4 color = new Vector4(1.0f, 0.5f, 0.2f, 1.0f);

Vector2、Vector3、Vector4は、主に座標、方向、速度、色、クォータニオン関連の計算などで使います。高速化目的というより、数学的なベクトルをわかりやすく表現する目的で使われることが多いです。

1-4. C#でVectorを使う主な目的

C#でVectorを使う主な目的は、数値計算を効率化することです。特にVector<T>は、同じ演算を大量のデータに対して繰り返す場面で効果を発揮します。

代表的な用途は次のような処理です。

配列同士の加算、減算、乗算、除算を高速化したい場合に使えます。画像処理では、画素値の補正やフィルター処理に利用できます。音声処理では、サンプルデータの音量調整や波形変換に利用できます。ゲーム開発では、大量の座標や速度データを処理する場面で活用できます。データ分析や機械学習の前処理では、特徴量の正規化や行列風の計算に役立つことがあります。

ただし、Vectorを使えば必ず速くなるわけではありません。データ量が少ない場合や、条件分岐が多い場合、メモリアクセスが複雑な場合は、通常のfor文のほうがわかりやすく、十分に速いこともあります。

1-5. Vectorが向いている処理・向いていない処理

Vectorが向いているのは、同じ計算を連続した数値データに対して繰り返す処理です。たとえば、配列の全要素に同じ値を足す、2つの配列を要素ごとに足す、float配列の各要素を定数倍する、といった処理はVectorと相性がよいです。

一方で、Vectorが向いていない処理もあります。各要素ごとに複雑な条件分岐がある処理、文字列処理、オブジェクト参照を多く含む処理、データが連続していない処理、小さすぎる配列の処理などです。

Vectorは「大量の数値を同じルールで処理する」ときに使うと効果が出やすい、と覚えておくとよいでしょう。

2. System.Numerics.Vectorを使うための準備

2-1. 利用に必要な名前空間

C#でVector<T>、Vector2、Vector3、Vector4を使うには、基本的に次の名前空間を追加します。

C#
using System.Numerics;

これにより、次のような型をコード内で使えるようになります。

C#
Vector<int>
Vector<float>
Vector<double>
Vector2
Vector3
Vector4

.NETプロジェクトの種類によっては、追加のNuGetパッケージが必要になる場合もあります。古い.NET Framework環境では、System.Numerics.Vectorsパッケージの参照が必要になることがあります。

現在の.NET環境で新しいコンソールアプリやWebアプリを作成している場合は、多くのケースでusing System.Numerics;を追加するだけで利用できます。

2-2. 対応している.NET環境

System.Numerics.Vector<T>は、.NETで利用できるSIMD対応の数値型です。現在の.NETでは、System.Numerics名前空間にSIMDアクセラレーション対応の型が含まれています。Microsoft Learn

ただし、実際にハードウェアアクセラレーションが有効になるかどうかは、次の要素に依存します。

実行している.NETランタイムのバージョン、CPUの対応命令、JITコンパイラの対応状況、アプリケーションの実行環境、ビルド設定などです。

そのため、Vector<T>を使ったコードが書けることと、実際にSIMDで高速化されることは別です。高速化されているか確認したい場合は、Vector.IsHardwareAcceleratedを使います。

2-3. Vector<T>で扱える主な数値型

Vector<T>のTには、主にプリミティブな数値型を指定します。代表的な型は次のとおりです。

C#
Vector<byte>
Vector<short>
Vector<int>
Vector<long>
Vector<float>
Vector<double>

よく使われるのは、Vector<int>、Vector<float>、Vector<double>です。画像処理ではbyteやfloat、科学計算や機械学習ではfloatやdouble、整数配列の処理ではintがよく使われます。

一方で、任意のクラス型や構造体をVector<T>に指定できるわけではありません。Vector<string>やVector<object>のような使い方はできません。Vector<T>は数値計算のための型であり、文字列や一般オブジェクトをまとめて処理するためのものではありません。

2-4. SIMDとは何かを初心者向けに解説

SIMDとは「Single Instruction, Multiple Data」の略です。日本語では「単一命令・複数データ」と訳されます。

通常のfor文では、1回の処理で1つのデータを計算します。

C#
result[0] = a[0] + b[0];
result[1] = a[1] + b[1];
result[2] = a[2] + b[2];
result[3] = a[3] + b[3];

SIMDでは、これら複数のデータに対する同じ演算を、1つの命令でまとめて実行できます。

[a0, a1, a2, a3] + [b0, b1, b2, b3]

つまり、1つずつ足すのではなく、複数の値をまとめて足します。Microsoftの公式ドキュメントでも、SIMDは1つの命令で複数のデータに対する操作を並列に実行するハードウェア支援として説明されています。Microsoft Learn

C#でVector<T>を使うと、このSIMDを直接アセンブリで書かなくても、比較的簡単に利用できます。

2-5. Vector.IsHardwareAcceleratedで高速化対応を確認する方法

Vector<T>がハードウェアアクセラレーションの対象になっているか確認するには、Vector.IsHardwareAcceleratedを使います。

C#
using System;
using System.Numerics;

class Program
{
    static void Main()
    {
        Console.WriteLine(Vector.IsHardwareAccelerated);
    }
}

trueが表示されれば、Vector演算がJITの組み込みサポートによりハードウェアアクセラレーションの対象になっています。Microsoftの公式ドキュメントでも、Vector.IsHardwareAcceleratedはVector演算がJIT intrinsic supportによってハードウェアアクセラレーション対象になるかを示すプロパティと説明されています。Microsoft Learn

ただし、trueだからといってすべての処理が自動的に高速化されるわけではありません。Vectorに向いた処理を書いているか、データ量が十分にあるか、端数処理が適切か、メモリアクセスが効率的かといった点も重要です。

3. C# Vector<T>の基本的な使い方

3-1. Vector<T>のインスタンスを作成する方法

Vector<T>のインスタンスは、コンストラクタを使って作成できます。すべての要素に同じ値を入れたい場合は、次のように書きます。

C#
using System;
using System.Numerics;

class Program
{
    static void Main()
    {
        Vector<int> v = new Vector<int>(10);

        Console.WriteLine(v);
    }
}

この場合、vのすべての要素に10が入ります。要素数はVector<int>.Countで確認できます。

C#
Console.WriteLine(Vector<int>.Count);

Vector<T>は、通常の配列のように「要素数を自由に指定して作る型」ではありません。1つのVectorに入る要素数は、型と実行環境によって決まります。

3-2. 配列からVector<T>を生成する方法

配列からVector<T>を生成するには、配列をコンストラクタに渡します。

C#
int[] values = { 1, 2, 3, 4, 5, 6, 7, 8 };

Vector<int> v = new Vector<int>(values);

ただし、配列の長さはVector<int>.Count以上である必要があります。配列の途中から読み込みたい場合は、開始位置を指定できます。

C#
int[] values = { 1, 2, 3, 4, 5, 6, 7, 8 };

Vector<int> v = new Vector<int>(values, 0);

開始位置を変えると、配列の途中からVectorを作成できます。

C#
Vector<int> v2 = new Vector<int>(values, Vector<int>.Count);

この書き方は、大きな配列をVector<T>の単位で順番に処理するときによく使います。

3-3. Vector<T>同士で加算・減算・乗算・除算する方法

Vector<T>同士は、通常の数値のように演算子で計算できます。

C#
using System;
using System.Numerics;

class Program
{
    static void Main()
    {
        Vector<float> a = new Vector<float>(2.0f);
        Vector<float> b = new Vector<float>(3.0f);

        Vector<float> add = a + b;
        Vector<float> sub = a - b;
        Vector<float> mul = a * b;
        Vector<float> div = b / a;

        Console.WriteLine(add);
        Console.WriteLine(sub);
        Console.WriteLine(mul);
        Console.WriteLine(div);
    }
}

a + bは、Vector内の各要素をまとめて加算します。通常の配列で書くと、各要素に対して次の処理をしているイメージです。

C#
result[i] = a[i] + b[i];

ただし、Vector<T>では複数の要素をまとめて処理できます。

3-4. Vector<T>の要素数を確認する方法

Vector<T>の要素数を確認するには、Vector<T>.Countを使います。

C#
Console.WriteLine(Vector<int>.Count);
Console.WriteLine(Vector<float>.Count);
Console.WriteLine(Vector<double>.Count);

Vector<T>.Countは、1つのVector<T>に格納できる要素数を返します。たとえば、Vector<float>.Countが8であれば、1回のVector演算でfloat値を8個まとめて処理できることを意味します。

重要なのは、Vector<T>.Countの値が環境によって変わる可能性があることです。そのため、コード内で4や8のように固定値を書くのではなく、必ずVector<T>.Countを使うようにします。

3-5. Vector<T>から配列へ結果を書き戻す方法

Vector<T>で計算した結果を配列に戻すには、CopyToメソッドを使います。

C#
using System;
using System.Numerics;

class Program
{
    static void Main()
    {
        float[] result = new float[Vector<float>.Count];

        Vector<float> a = new Vector<float>(2.0f);
        Vector<float> b = new Vector<float>(3.0f);

        Vector<float> c = a + b;

        c.CopyTo(result);

        foreach (float value in result)
        {
            Console.WriteLine(value);
        }
    }
}

配列の途中に書き戻したい場合は、開始位置を指定します。

C#
c.CopyTo(result, 0);

大量の配列を処理する場合は、new Vector<T>(array, i)で読み込み、演算し、CopyTo(result, i)で書き戻す流れが基本になります。

4. C# Vectorの実践サンプルコード

4-1. 配列の全要素を一括で加算するサンプル

まずは、配列の全要素に同じ値を足すサンプルです。

通常のfor文では次のように書きます。

C#
for (int i = 0; i < values.Length; i++)
{
    values[i] += 10;
}

Vector<T>を使うと、次のように書けます。

C#
using System;
using System.Numerics;

class Program
{
    static void Main()
    {
        int[] values = new int[1000];

        for (int i = 0; i < values.Length; i++)
        {
            values[i] = i;
        }

        AddValue(values, 10);

        Console.WriteLine(values[0]);
        Console.WriteLine(values[999]);
    }

    static void AddValue(int[] values, int addValue)
    {
        int vectorSize = Vector<int>.Count;
        Vector<int> addVector = new Vector<int>(addValue);

        int i = 0;

        for (; i <= values.Length - vectorSize; i += vectorSize)
        {
            Vector<int> v = new Vector<int>(values, i);
            v += addVector;
            v.CopyTo(values, i);
        }

        for (; i < values.Length; i++)
        {
            values[i] += addValue;
        }
    }
}

前半のfor文では、Vector<int>.Count個ずつまとめて処理しています。後半のfor文では、Vector単位で処理しきれなかった端数を通常の方法で処理しています。

4-2. 配列同士を高速に足し合わせるサンプル

2つの配列を要素ごとに足して、結果を別の配列へ入れるサンプルです。

C#
using System;
using System.Numerics;

class Program
{
    static void Main()
    {
        int[] a = new int[1000];
        int[] b = new int[1000];
        int[] result = new int[1000];

        for (int i = 0; i < a.Length; i++)
        {
            a[i] = i;
            b[i] = i * 2;
        }

        AddArrays(a, b, result);

        Console.WriteLine(result[10]);
    }

    static void AddArrays(int[] a, int[] b, int[] result)
    {
        int vectorSize = Vector<int>.Count;
        int i = 0;

        for (; i <= a.Length - vectorSize; i += vectorSize)
        {
            Vector<int> va = new Vector<int>(a, i);
            Vector<int> vb = new Vector<int>(b, i);

            Vector<int> vr = va + vb;

            vr.CopyTo(result, i);
        }

        for (; i < a.Length; i++)
        {
            result[i] = a[i] + b[i];
        }
    }
}

このコードでは、aとbから同じ位置の要素をまとめて読み込み、まとめて加算しています。大量の整数配列を処理する場合に有効です。

実務では、配列の長さが一致しているかをチェックする処理も追加すると安全です。

C#
if (a.Length != b.Length || a.Length != result.Length)
{
    throw new ArgumentException("配列の長さが一致していません。");
}

4-3. float配列の乗算処理を高速化するサンプル

float配列の各要素に係数を掛ける処理は、Vectorと相性がよい代表例です。画像処理、音声処理、数値シミュレーションなどでよく出てきます。

C#
using System;
using System.Numerics;

class Program
{
    static void Main()
    {
        float[] samples = new float[1000];

        for (int i = 0; i < samples.Length; i++)
        {
            samples[i] = i * 0.1f;
        }

        Multiply(samples, 1.5f);

        Console.WriteLine(samples[10]);
    }

    static void Multiply(float[] values, float factor)
    {
        int vectorSize = Vector<float>.Count;
        Vector<float> factorVector = new Vector<float>(factor);

        int i = 0;

        for (; i <= values.Length - vectorSize; i += vectorSize)
        {
            Vector<float> v = new Vector<float>(values, i);
            v *= factorVector;
            v.CopyTo(values, i);
        }

        for (; i < values.Length; i++)
        {
            values[i] *= factor;
        }
    }
}

Vector<float>は、intよりも画像処理や音声処理で使われることが多い型です。CPUのSIMD命令との相性がよく、大量データでは効果を確認しやすいケースがあります。

4-4. 合計値を求める処理のサンプル

配列の合計値を求める処理も、Vector<T>である程度高速化できます。ただし、最後にVector内の各要素を合計する処理が必要です。

C#
using System;
using System.Numerics;

class Program
{
    static void Main()
    {
        float[] values = new float[1000];

        for (int i = 0; i < values.Length; i++)
        {
            values[i] = 1.0f;
        }

        float sum = Sum(values);

        Console.WriteLine(sum);
    }

    static float Sum(float[] values)
    {
        int vectorSize = Vector<float>.Count;
        Vector<float> sumVector = Vector<float>.Zero;

        int i = 0;

        for (; i <= values.Length - vectorSize; i += vectorSize)
        {
            Vector<float> v = new Vector<float>(values, i);
            sumVector += v;
        }

        float sum = 0;

        for (int j = 0; j < vectorSize; j++)
        {
            sum += sumVector[j];
        }

        for (; i < values.Length; i++)
        {
            sum += values[i];
        }

        return sum;
    }
}

このサンプルでは、まずVector単位で合計を蓄積し、その後sumVector[j]でVector内の要素を取り出して最終的な合計値にしています。

4-5. Vector<T>で端数の要素を処理する方法

Vector<T>を使うときに重要なのが端数処理です。

たとえば、配列の長さが1000で、Vector<float>.Countが8の場合、8個ずつ処理すると最後に余りが出る可能性があります。この余りを処理しないと、配列の末尾の値が計算されません。

基本形は次のとおりです。

C#
int vectorSize = Vector<float>.Count;
int i = 0;

for (; i <= values.Length - vectorSize; i += vectorSize)
{
    Vector<float> v = new Vector<float>(values, i);

    // Vectorを使った処理

    v.CopyTo(values, i);
}

for (; i < values.Length; i++)
{
    // 端数を通常の方法で処理
}

この形は、Vector<T>を使ううえで非常によく出てきます。初心者のうちは、Vector処理と端数処理をセットで書くと覚えておくと安全です。

5. Vector2・Vector3・Vector4の使い方

5-1. Vector2とは

Vector2は、2つのfloat値を持つベクトル型です。主に2D座標や2D方向ベクトルを表すために使います。

C#
using System;
using System.Numerics;

class Program
{
    static void Main()
    {
        Vector2 position = new Vector2(10.0f, 20.0f);
        Vector2 velocity = new Vector2(1.0f, 0.5f);

        position += velocity;

        Console.WriteLine(position);
    }
}

Vector2には、XとYの2つの要素があります。

C#
Console.WriteLine(position.X);
Console.WriteLine(position.Y);

2Dゲームでキャラクターの位置を管理したり、マウス座標を扱ったり、画面上の移動方向を表したりするときに便利です。

5-2. Vector3とは

Vector3は、3つのfloat値を持つベクトル型です。主に3D座標、方向、速度、法線ベクトルなどを表すために使います。

C#
using System;
using System.Numerics;

class Program
{
    static void Main()
    {
        Vector3 position = new Vector3(10.0f, 20.0f, 30.0f);
        Vector3 direction = new Vector3(0.0f, 1.0f, 0.0f);

        Vector3 next = position + direction;

        Console.WriteLine(next);
    }
}

Vector3には、X、Y、Zの3つの要素があります。

C#
Console.WriteLine(position.X);
Console.WriteLine(position.Y);
Console.WriteLine(position.Z);

3Dゲームや3Dグラフィックスでは、位置、向き、移動量、光の方向、面の法線などを表すために頻繁に使われます。

5-3. Vector4とは

Vector4は、4つのfloat値を持つベクトル型です。X、Y、Z、Wの4要素を持ちます。

C#
using System;
using System.Numerics;

class Program
{
    static void Main()
    {
        Vector4 color = new Vector4(1.0f, 0.5f, 0.2f, 1.0f);

        Console.WriteLine(color.X);
        Console.WriteLine(color.Y);
        Console.WriteLine(color.Z);
        Console.WriteLine(color.W);
    }
}

Vector4は、4次元ベクトル、同次座標、RGBAカラー、行列計算と組み合わせた変換処理などで使われます。

たとえば、RGBAカラーをVector4で表す場合、次のように考えられます。

C#
Vector4 rgba = new Vector4(red, green, blue, alpha);

5-4. 座標・ゲーム・3D計算での利用例

Vector2、Vector3、Vector4は、数学的なベクトルをコード上で自然に表現できる点が大きなメリットです。

たとえば、2Dゲームでプレイヤーを移動させる処理は次のように書けます。

C#
Vector2 position = new Vector2(100.0f, 50.0f);
Vector2 velocity = new Vector2(2.0f, 0.0f);

position += velocity;

3D空間でオブジェクトを移動させる場合は、Vector3を使います。

C#
Vector3 position = new Vector3(0.0f, 0.0f, 0.0f);
Vector3 velocity = new Vector3(0.0f, 1.0f, 0.0f);

position += velocity;

ベクトルの長さを求めることもできます。

C#
float length = position.Length();

正規化も簡単です。

C#
Vector3 normalized = Vector3.Normalize(position);

内積を求める場合は、Vector3.Dotを使います。

C#
float dot = Vector3.Dot(position, velocity);

このように、Vector2、Vector3、Vector4は、座標計算やゲーム開発で非常に使いやすい型です。

5-5. Vector<T>とVector2・Vector3・Vector4の使い分け

Vector<T>とVector2、Vector3、Vector4は、目的で使い分けます。

大量の配列データを高速に処理したい場合は、Vector<T>を使います。たとえば、float[]の全要素を定数倍する、int[]同士を足す、画像の画素値をまとめて変換するといった処理です。

座標や方向を表したい場合は、Vector2、Vector3、Vector4を使います。2D座標ならVector2、3D座標ならVector3、4要素のデータならVector4が適しています。

つまり、Vector<T>は高速化寄り、Vector2、Vector3、Vector4は数学表現寄りと考えるとわかりやすいです。

6. C# Vectorで高速化できる理由

6-1. 通常のfor文との違い

通常のfor文では、基本的に1回のループで1つの要素を処理します。

C#
for (int i = 0; i < values.Length; i++)
{
    values[i] *= 2;
}

この処理はシンプルで読みやすいですが、大量のデータを扱う場合、1要素ずつ処理するコストが積み重なります。

Vector<T>を使うと、1回のループで複数の要素をまとめて処理します。

C#
for (; i <= values.Length - vectorSize; i += vectorSize)
{
    Vector<int> v = new Vector<int>(values, i);
    v *= multiplier;
    v.CopyTo(values, i);
}

ループ回数が減り、さらにCPUがSIMD命令を使える場合は、複数の値を並列に計算できます。これが、Vector<T>で高速化できる基本的な理由です。

6-2. SIMDによる並列計算の仕組み

SIMDでは、複数のデータに対して同じ命令をまとめて実行します。

たとえば、4つのfloat値を足す処理を考えます。

a = [1.0, 2.0, 3.0, 4.0]
b = [10.0, 20.0, 30.0, 40.0]

通常の処理では、次のように1つずつ足します。

1.0 + 10.0
2.0 + 20.0
3.0 + 30.0
4.0 + 40.0

SIMDでは、次のようにまとめて足すイメージです。

[1.0, 2.0, 3.0, 4.0] + [10.0, 20.0, 30.0, 40.0]

結果は次のようになります。

[11.0, 22.0, 33.0, 44.0]

Vector<T>は、このようなまとめて計算する考え方をC#から扱いやすくしたものです。

6-3. CPU命令とハードウェアアクセラレーションの関係

SIMDによる高速化は、CPUの命令セットに依存します。代表的なものには、SSE、AVX、AVX2、AVX-512、ARM NEONなどがあります。

Vector<T>を使うと、C#のコードから直接これらの命令を指定するわけではありません。JITコンパイラが実行環境に応じて適切な命令を使える場合に、ハードウェアアクセラレーションの対象になります。

この状態を確認するのが、Vector.IsHardwareAcceleratedです。

C#
if (Vector.IsHardwareAccelerated)
{
    Console.WriteLine("Vector演算はハードウェアアクセラレーションの対象です。");
}
else
{
    Console.WriteLine("Vector演算はハードウェアアクセラレーションの対象ではありません。");
}

falseの場合でもコード自体は動作することがありますが、期待した速度が出ない可能性があります。

6-4. Vector<T>の要素数が環境によって変わる理由

Vector<T>の要素数は、Vector<T>.Countで決まります。この値は、型と実行環境によって変わります。

たとえば、floatは1要素が4バイト、doubleは1要素が8バイトです。SIMDレジスタの幅が同じなら、floatのほうがdoubleより多くの要素を格納できます。

そのため、次のようなコードで確認することが大切です。

C#
Console.WriteLine(Vector<float>.Count);
Console.WriteLine(Vector<double>.Count);
Console.WriteLine(Vector<int>.Count);

コードを書くときは、Vector<float>.Countが必ず4である、Vector<int>.Countが必ず8である、という前提を置かないようにします。

正しい書き方は次のように、常にVector<T>.Countを基準にループを組むことです。

C#
int vectorSize = Vector<float>.Count;

これにより、環境が変わっても動きやすいコードになります。

6-5. 高速化の効果が出やすい処理パターン

Vector<T>で高速化の効果が出やすいのは、次のような処理です。

大量の数値配列を処理する場合、各要素に同じ演算を行う場合、データが連続した配列に格納されている場合、条件分岐が少ない場合、メモリアクセスが単純な場合です。

たとえば、次の処理はVectorと相性がよいです。

C#
result[i] = a[i] + b[i];
result[i] = a[i] * 1.5f;
result[i] = MathF.Sqrt(a[i]);
result[i] = MathF.Min(a[i], b[i]);

一方で、次のような処理は効果が出にくいことがあります。

C#
if (values[i] > threshold)
{
    result[i] = ComplexCalculation(values[i]);
}
else
{
    result[i] = AnotherCalculation(values[i]);
}

条件分岐が多いと、Vector化しづらくなります。Vectorは、同じ演算をまとめて実行できる処理で最も力を発揮します。

7. Vector<T>のパフォーマンス比較

7-1. 通常ループとVector<T>の比較

通常ループとVector<T>の違いを比較する簡単な例を見てみましょう。

通常ループは次のように書けます。

C#
static void AddNormal(float[] a, float[] b, float[] result)
{
    for (int i = 0; i < a.Length; i++)
    {
        result[i] = a[i] + b[i];
    }
}

Vector<T>を使う場合は次のようになります。

C#
static void AddVector(float[] a, float[] b, float[] result)
{
    int vectorSize = Vector<float>.Count;
    int i = 0;

    for (; i <= a.Length - vectorSize; i += vectorSize)
    {
        Vector<float> va = new Vector<float>(a, i);
        Vector<float> vb = new Vector<float>(b, i);

        Vector<float> vr = va + vb;

        vr.CopyTo(result, i);
    }

    for (; i < a.Length; i++)
    {
        result[i] = a[i] + b[i];
    }
}

通常ループは読みやすく、保守しやすいのがメリットです。一方、Vector<T>はコード量が増えますが、大量データでは高速化できる可能性があります。

実務では、まず通常ループで正しく実装し、パフォーマンス上の問題が明確になった段階でVector化を検討するのが現実的です。

7-2. LINQとVector<T>の比較

LINQを使うと、配列処理を短く書けます。

C#
float[] result = a.Zip(b, (x, y) => x + y).ToArray();

このコードは非常に読みやすいですが、大量データの高頻度な数値計算では、通常のfor文やVector<T>より遅くなることがあります。LINQは抽象度が高く、列挙処理やデリゲート呼び出しなどのオーバーヘッドが発生しやすいためです。

パフォーマンスを重視する場面では、LINQよりも通常のfor文、さらに必要であればVector<T>を検討します。

ただし、設定処理や小規模なデータ変換、読みやすさを重視する業務コードではLINQのほうが適している場合もあります。速度だけでなく、可読性や保守性も考慮しましょう。

7-3. Span<T>と組み合わせた場合の比較

Span<T>は、配列やメモリ領域を効率よく扱うための型です。Vector<T>と直接組み合わせることで、配列以外の連続メモリを扱う設計にしやすくなります。

たとえば、メソッドの引数を配列ではなくReadOnlySpan<float>やSpan<float>にすると、より柔軟なコードになります。

C#
static void Add(ReadOnlySpan<float> a, ReadOnlySpan<float> b, Span<float> result)
{
    int vectorSize = Vector<float>.Count;
    int i = 0;

    for (; i <= a.Length - vectorSize; i += vectorSize)
    {
        Vector<float> va = new Vector<float>(a.Slice(i));
        Vector<float> vb = new Vector<float>(b.Slice(i));

        Vector<float> vr = va + vb;

        vr.CopyTo(result.Slice(i));
    }

    for (; i < a.Length; i++)
    {
        result[i] = a[i] + b[i];
    }
}

Span<T>を使うと、配列全体だけでなく一部の範囲を効率よく扱えます。ただし、初心者のうちは配列版で基本を理解してから、必要に応じてSpan<T>版に進むのがおすすめです。

7-4. ベンチマークを取るときの注意点

Vector<T>の効果を確認するには、正しくベンチマークを取る必要があります。単純にDateTime.Nowで前後の時間を測るだけでは、正確な比較になりにくいです。

最低限、次の点に注意しましょう。

デバッグビルドではなくリリースビルドで測定すること、Visual Studioのデバッガー実行ではなく通常実行で確認すること、処理を1回だけでなく複数回実行すること、JITコンパイルの影響を考慮すること、十分に大きなデータで測ることが重要です。

本格的に測定する場合は、BenchmarkDotNetのようなベンチマーク用ライブラリを使うと便利です。

簡易的に測る場合でも、次のようにStopwatchを使うほうがよいです。

C#
using System.Diagnostics;

Stopwatch sw = Stopwatch.StartNew();

// 測定したい処理

sw.Stop();

Console.WriteLine(sw.ElapsedMilliseconds);

ただし、短すぎる処理では誤差が大きくなります。ベンチマークでは、実際の利用状況に近いデータ量と処理内容で比較することが大切です。

7-5. 高速化されない場合に確認すべきポイント

Vector<T>を使っても期待したほど速くならない場合は、次の点を確認します。

まず、Vector.IsHardwareAcceleratedがtrueになっているか確認します。次に、データ量が十分に大きいか確認します。小さな配列では、Vector化の準備やループ処理のオーバーヘッドが目立ち、効果が出にくい場合があります。

また、処理内容がVectorに向いているかも重要です。条件分岐が多い、メモリアクセスが不規則、メソッド呼び出しが多い、配列境界チェックが多いといった場合、期待した速度が出ないことがあります。

さらに、LINQや不要な配列生成が混ざっていると、Vector化した部分以外がボトルネックになることもあります。

パフォーマンス改善では、「どこが遅いのか」を測定してから最適化することが重要です。

8. C# Vectorを使うときの注意点

8-1. すべての処理が速くなるわけではない

Vector<T>は便利ですが、すべての処理を速くする魔法の道具ではありません。高速化できるのは、主に数値データに対して同じ処理をまとめて実行できる場合です。

たとえば、文字列の加工、複雑なオブジェクト操作、データベースアクセス、ファイルI/O、ネットワーク通信などは、Vector<T>ではほとんど改善できません。

Vector<T>が役立つのは、CPU上で大量の数値演算を行っている場合です。まずはアプリケーションのボトルネックが本当に数値計算なのかを確認しましょう。

8-2. 小さな配列では効果が出にくい

Vector<T>は、複数要素をまとめて処理するため、大量データでは効果を発揮しやすいです。しかし、配列の要素数が少ない場合は、通常のfor文との差がほとんど出ないことがあります。

たとえば、10個程度の配列を1回だけ処理する場合、Vector化しても体感できる差はほぼありません。むしろコードが複雑になる分、保守性が下がる可能性があります。

小さなデータでは通常のfor文、大量データではVector<T>を検討する、という使い分けが現実的です。

8-3. 端数処理を忘れるとバグになる

Vector<T>では、Vector<T>.Count個ずつ処理します。そのため、配列の長さがVector<T>.Countで割り切れない場合、末尾の要素が余ります。

この端数を処理しないと、最後の数個の要素だけ計算されないバグになります。

悪い例は次のようなコードです。

C#
for (int i = 0; i < values.Length; i += Vector<float>.Count)
{
    Vector<float> v = new Vector<float>(values, i);
    v *= factor;
    v.CopyTo(values, i);
}

このコードは、配列の末尾でVector<float>.Count分の要素が足りない場合に例外が発生する可能性があります。

安全な書き方は次のとおりです。

C#
int vectorSize = Vector<float>.Count;
int i = 0;

for (; i <= values.Length - vectorSize; i += vectorSize)
{
    Vector<float> v = new Vector<float>(values, i);
    v *= factor;
    v.CopyTo(values, i);
}

for (; i < values.Length; i++)
{
    values[i] *= factor;
}

端数処理は、Vectorを使うときの基本です。

8-4. 可読性と保守性のバランス

Vector<T>を使うと、通常のfor文よりコードが複雑になります。特に初心者にとっては、Vector<T>.Count、端数処理、CopyToなどが加わるため、読みにくく感じるかもしれません。

業務コードでは、速度だけでなく可読性と保守性も重要です。多少速くなっても、チーム全員が理解できないコードになってしまうと、将来の修正でバグが入りやすくなります。

おすすめの進め方は、まず通常のfor文でわかりやすく実装し、パフォーマンス測定で問題があることを確認してからVector化することです。

また、Vector化した処理は専用メソッドに分け、メソッド名で意図がわかるようにすると保守しやすくなります。

C#
static void AddArraysVectorized(float[] a, float[] b, float[] result)
{
    // Vector化した処理
}

8-5. 実行環境による速度差に注意する

Vector<T>のパフォーマンスは、実行環境に依存します。同じコードでも、CPU、OS、.NETランタイム、ビルド設定によって速度が変わることがあります。

開発PCでは速くても、本番環境では期待したほど速くない場合があります。逆に、本番環境のCPUが強力であれば、開発PCより大きな効果が出ることもあります。

そのため、パフォーマンスを重視する場合は、できるだけ本番に近い環境で測定しましょう。

9. C# Vectorでよく使うメソッド・プロパティ

9-1. Vector.Count

Vector<T>.Countは、1つのVector<T>に格納できる要素数を返します。

C#
int count = Vector<float>.Count;
Console.WriteLine(count);

Vector<T>を使ったループでは、この値を基準に処理します。

C#
int vectorSize = Vector<float>.Count;

for (int i = 0; i <= values.Length - vectorSize; i += vectorSize)
{
    // Vector単位の処理
}

Vector<T>.Countの値は環境によって変わる可能性があるため、固定値を使わないことが大切です。

9-2. Vector.IsHardwareAccelerated

Vector.IsHardwareAcceleratedは、Vector演算がハードウェアアクセラレーションの対象かどうかを確認するプロパティです。

C#
Console.WriteLine(Vector.IsHardwareAccelerated);

trueなら、JITのサポートによりVector演算がハードウェアアクセラレーションの対象になります。Microsoft Learn

ただし、trueでも処理内容によっては期待したほど高速化されないことがあります。あくまで「利用可能かどうか」を確認するためのプロパティです。

9-3. Vector.Dot

Vector.Dotは、2つのVectorの内積を求めるメソッドです。

C#
Vector<float> a = new Vector<float>(2.0f);
Vector<float> b = new Vector<float>(3.0f);

float dot = Vector.Dot(a, b);

Console.WriteLine(dot);

内積は、対応する要素同士を掛け算し、その合計を求める計算です。

a[0] * b[0] + a[1] * b[1] + ...

機械学習、統計処理、類似度計算、ゲーム開発などで使われることがあります。

9-4. Vector.SquareRoot

Vector.SquareRootは、Vector内の各要素の平方根を求めます。

C#
Vector<float> values = new Vector<float>(16.0f);

Vector<float> result = Vector.SquareRoot(values);

Console.WriteLine(result);

通常であれば各要素に対してMathF.Sqrtを呼ぶ処理を、Vector単位で行えます。

C#
for (int i = 0; i < values.Length; i++)
{
    result[i] = MathF.Sqrt(values[i]);
}

平方根の計算を大量に行う場合に便利です。

9-5. Vector.Min・Vector.Max

Vector.Minは、2つのVectorを要素ごとに比較して小さい値を返します。Vector.Maxは大きい値を返します。

C#
Vector<float> a = new Vector<float>(10.0f);
Vector<float> b = new Vector<float>(20.0f);

Vector<float> min = Vector.Min(a, b);
Vector<float> max = Vector.Max(a, b);

配列の値を一定範囲に収める処理などに使えます。

C#
value = MathF.Min(value, maxValue);
value = MathF.Max(value, minValue);

画像処理で画素値を0から255の範囲に収めるような処理にも応用できます。

9-6. Vector.Equals・Vector.EqualsAll・Vector.EqualsAny

Vector.Equalsは、Vector同士の比較に使います。

C#
Vector<int> a = new Vector<int>(1);
Vector<int> b = new Vector<int>(1);

bool equals = a.Equals(b);

Console.WriteLine(equals);

Vector.EqualsAllは、すべての要素が等しいかを判定します。

C#
bool all = Vector.EqualsAll(a, b);

Vector.EqualsAnyは、いずれかの要素が等しいかを判定します。

C#
bool any = Vector.EqualsAny(a, b);

比較処理をVector単位で行いたい場合に使えます。

10. C# Vectorのよくあるエラーと解決方法

10-1. System.Numericsが見つからない場合

Vector<T>を使おうとして、System.Numericsが見つからない場合があります。

まず、ファイルの先頭に次のusingがあるか確認します。

C#
using System.Numerics;

それでも見つからない場合は、プロジェクトの対象フレームワークや参照設定を確認します。古い.NET Frameworkを使っている場合は、NuGetでSystem.Numerics.Vectorsパッケージを追加する必要があることがあります。

また、プロジェクトが非常に古い形式の場合、参照設定にSystem.Numericsを追加する必要がある場合もあります。

10-2. 型引数に指定できない型を使った場合

Vector<T>のTには、基本的に数値型を指定します。次のようなコードは使えません。

C#
Vector<string> v = new Vector<string>();

Vector<T>は数値計算のための型なので、文字列や一般的なクラス型は指定できません。

よく使う型は次のようなものです。

C#
Vector<int>
Vector<float>
Vector<double>
Vector<byte>

エラーが出た場合は、Tに指定している型がVector<T>で扱える数値型か確認しましょう。

10-3. 配列の長さ不足で例外が出る場合

配列からVector<T>を作る場合、指定した開始位置からVector<T>.Count個分の要素が必要です。

次のようなコードは、配列の長さによっては例外が発生します。

C#
Vector<float> v = new Vector<float>(values, i);

iから末尾までの要素数がVector<float>.Count未満だと、Vectorを作成できません。

安全に処理するには、次のようにループ条件を書きます。

C#
int vectorSize = Vector<float>.Count;

for (int i = 0; i <= values.Length - vectorSize; i += vectorSize)
{
    Vector<float> v = new Vector<float>(values, i);
}

端数は別のfor文で処理します。

C#
for (; i < values.Length; i++)
{
    // 端数処理
}

10-4. 期待したほど高速化されない場合

Vector<T>を使っても速くならない場合は、まずVector.IsHardwareAcceleratedを確認します。

C#
Console.WriteLine(Vector.IsHardwareAccelerated);

次に、リリースビルドで実行しているか、デバッガーなしで実行しているかを確認します。デバッグビルドでは最適化が十分に働かず、正しい速度比較にならないことがあります。

また、データ量が少なすぎる場合も高速化は見えにくいです。Vector<T>は大量データを処理する場合に効果が出やすいので、数十件程度のデータでは通常ループとの差がほとんどない場合があります。

さらに、処理全体のうちVector化した部分が小さいと、全体の速度改善は限定的です。ファイル読み込みやデータ変換、メモリ確保など別の部分がボトルネックになっていないかも確認しましょう。

10-5. Vector2とVector<T>を混同している場合

初心者がよく混同するのが、Vector2とVector<T>です。

Vector2は2D座標などを表すための型です。

C#
Vector2 position = new Vector2(10.0f, 20.0f);

一方、Vector<T>は大量の数値データをまとめて処理するための型です。

C#
Vector<float> values = new Vector<float>(1.0f);

配列を高速に処理したいならVector<T>、座標を表したいならVector2やVector3を使います。

「C# vector」と検索してサンプルコードを見たときは、それがVector<T>の話なのか、Vector2、Vector3、Vector4の話なのかを確認することが大切です。

11. C# Vectorの実務での活用例

11-1. 数値計算の高速化

Vector<T>は、数値計算の高速化に向いています。たとえば、シミュレーション、統計処理、金融計算、科学技術計算などで、大量の配列に対して同じ演算を繰り返す場合に活用できます。

例として、配列の各要素をスケーリングする処理があります。

C#
static void Scale(float[] values, float scale)
{
    int vectorSize = Vector<float>.Count;
    Vector<float> scaleVector = new Vector<float>(scale);

    int i = 0;

    for (; i <= values.Length - vectorSize; i += vectorSize)
    {
        Vector<float> v = new Vector<float>(values, i);
        v *= scaleVector;
        v.CopyTo(values, i);
    }

    for (; i < values.Length; i++)
    {
        values[i] *= scale;
    }
}

このような処理は単純ですが、データ量が多いと実行時間に差が出やすいです。

11-2. 画像処理での活用

画像処理では、画素値に対して同じ計算を繰り返すことが多くあります。明るさ調整、コントラスト補正、しきい値処理、フィルター処理などです。

たとえば、float配列で画素の明るさを管理している場合、すべての値に係数を掛ける処理はVector<T>で高速化しやすいです。

C#
static void AdjustBrightness(float[] pixels, float factor)
{
    int vectorSize = Vector<float>.Count;
    Vector<float> factorVector = new Vector<float>(factor);

    int i = 0;

    for (; i <= pixels.Length - vectorSize; i += vectorSize)
    {
        Vector<float> v = new Vector<float>(pixels, i);
        v *= factorVector;
        v.CopyTo(pixels, i);
    }

    for (; i < pixels.Length; i++)
    {
        pixels[i] *= factor;
    }
}

画素数が多い画像ほど、Vector化の効果が出やすくなります。ただし、実際の画像処理では値の範囲制限や色チャンネルの並びも考慮する必要があります。

11-3. 音声データ処理での活用

音声データは、サンプル値の配列として扱われることがよくあります。音量調整、フェードイン、フェードアウト、波形の合成などでは、配列の各要素に対して同じような演算を行います。

たとえば、音量を調整する処理は次のように書けます。

C#
static void ChangeVolume(float[] samples, float volume)
{
    int vectorSize = Vector<float>.Count;
    Vector<float> volumeVector = new Vector<float>(volume);

    int i = 0;

    for (; i <= samples.Length - vectorSize; i += vectorSize)
    {
        Vector<float> v = new Vector<float>(samples, i);
        v *= volumeVector;
        v.CopyTo(samples, i);
    }

    for (; i < samples.Length; i++)
    {
        samples[i] *= volume;
    }
}

音声データはサンプル数が多いため、Vector化と相性がよいケースがあります。

11-4. ゲーム開発での活用

ゲーム開発では、Vector2やVector3がよく使われます。プレイヤーの位置、敵の移動方向、弾の速度、カメラの向きなどを表すのに便利です。

C#
Vector3 position = new Vector3(0.0f, 0.0f, 0.0f);
Vector3 velocity = new Vector3(1.0f, 0.0f, 0.0f);

position += velocity;

一方で、大量の座標データや物理データをまとめて処理する場合は、Vector<T>が使える場面もあります。

たとえば、たくさんのオブジェクトのX座標だけを配列で管理している場合、Vector<float>でまとめて更新できます。

C#
static void MoveX(float[] xPositions, float speed)
{
    int vectorSize = Vector<float>.Count;
    Vector<float> speedVector = new Vector<float>(speed);

    int i = 0;

    for (; i <= xPositions.Length - vectorSize; i += vectorSize)
    {
        Vector<float> v = new Vector<float>(xPositions, i);
        v += speedVector;
        v.CopyTo(xPositions, i);
    }

    for (; i < xPositions.Length; i++)
    {
        xPositions[i] += speed;
    }
}