ファイル名に日時を入れています。

今日なら、251103ファイル名

プログラムで自動的にクリップボードへ入れてペーストして使っていた。

 

そのプログラムを強化した。

いちいち、プログラム起動ボタンを押すのがへきへきしてきたため。

 

これまでは、起動と同時に、6桁文字列作成、クリップボードへ貼り付け、プログラム終了としていた。

 

ChatCPTの力を借り、以下のコードを作成した。

常駐プログラムとして起動。

右クリックを5回でクリップボードにペースト。

もしくは、右ドラッグ

でペースト

とした。

 

// DateGestureClipper_Tray.cpp
// Win11 + MSVC 2022 /SUBSYSTEM:WINDOWS  1ファイル完結(コンソール非表示)
//
// 目的:
//  - 現在の日付「yyMMdd」をクリップボードへコピー(例:251103)
//  - 常駐監視:右クリック5連打、または右ドラッグの円ジェスチャで発火
//  - 無音フィードバック:半透明の小さなOSDを一瞬だけ表示(約0.9秒)
//  - タスクトレイ(通知領域)に常駐アイコンを出し、以下のメニューを提供:
//      * 「YYMMDD」      → 即コピー
//      * 「バージョン情報」→ “mk 2025 ChatGPT” を表示
//      * 「終了」         → 安全に終了
//  - トレイアイコン左クリックでも即コピー
//
// 使い方:
//  - Windowsアプリケーション(/SUBSYSTEM:WINDOWS)で新規プロジェクトを作り、
//    このファイルを追加してビルド。生成EXEを起動すると非表示で常駐します。
//  - スタートアップ登録は Win+R → shell:startup にショートカットを置くと便利。
//  - 開発中・運用中に終了したい場合は、タスクトレイのアイコンを右クリック→「終了」。
//    (左クリックは即コピー、右クリックはメニュー)
//
// 重要設計メモ:
//  - 低レベルマウスフック (WH_MOUSE_LL) はプロセス境界を越えてグローバルに動くため、
//    フック解除・終了時の後始末(UnhookWindowsHookEx)が重要。本コードはメイン隠しウィンドウの
//    ライフサイクルに紐づけて安全に管理しています。
//  - OSDはウィンドウプロシージャ(同一スレッド)内のタイマーで自壊させ、他スレッドDestroy問題を回避。
//  - トレイアイコンは NOTIFYICONDATA(uCallbackMessage) を使って独自メッセージ (WM_APP+1) を受け取り、
//    左クリック/右クリックの振る舞いを実装。
//  - 角度正規化は <numbers> の std::numbers::pi_v<double> を使用(M_PI 非依存)。
//  - すべての可視UIは「最前面・非アクティブ・透過」の小窓のみ(フォーカスを奪わない)。
//
#include <windows.h>
#include <shellapi.h>
#include <string>
#include <vector>
#include <atomic>
#include <numbers>   // std::numbers::pi_v<double>
#include <cmath>

#pragma comment(lib, "user32.lib")
#pragma comment(lib, "gdi32.lib")
#pragma comment(lib, "shell32.lib")

//========================= 調整用パラメータ =========================//
// 5連打(右クリック)関連
constexpr DWORD  TAP_WINDOW_MS = 800;    // 5回をこの時間内に
constexpr int    TAP_COUNT_TARGET = 5;      // 目標クリック回数
constexpr DWORD  FIRE_GUARD_MS = 300;    // 誤連発ガード間隔(ms)

// 円ジェスチャ関連(右ボタン押下中に円を描いたら発火)
constexpr double MIN_PATH_LEN = 200.0;  // 総軌跡長がこれ未満なら無視
constexpr double MIN_SWEEP_RAD = 4.5;    // 累積回転角の下限 (rad) ≒ 260°
constexpr double MAX_REL_RADIUS_STD = 0.35;   // 半径の相対標準偏差(円らしさ)
constexpr int    MIN_POINTS = 30;     // 判定に必要な最低点数

// OSD(無音ポップアップ)関連
constexpr UINT   OSD_LIFETIME_MS = 900;    // 表示時間
constexpr int    OSD_W = 240;    // 幅
constexpr int    OSD_H = 48;     // 高さ
constexpr BYTE   OSD_ALPHA = 230;    // 不透明度(0-255)

// トレイアイコン関連
constexpr UINT   WMAPP_TRAYICON = WM_APP + 1;  // コールバック用メッセージ
constexpr UINT   ID_TRAY_COPY = 1001;        // メニュー:YYMMDD
constexpr UINT   ID_TRAY_ABOUT = 1002;        // メニュー:バージョン情報
constexpr UINT   ID_TRAY_EXIT = 1003;        // メニュー:終了

// 隠しメインウィンドウのクラス名
static const wchar_t* kMainWndClass = L"DateGestureClipperHiddenMainWnd";
// OSD小窓のクラス名
static const wchar_t* kOSDClass = L"DateClipOSDWndClass";

//========================= グローバル状態 =========================//
// (注)最低限に留める。終了時の掃除を確実に。
HHOOK                   g_hMouseLL = nullptr;     // 低レベルマウスフック
NOTIFYICONDATAW         g_nid{};                  // トレイアイコン情報
std::atomic<DWORD>      g_lastFire{ 0 };          // 連発ガード用タイムスタンプ

// 右クリック5連打の状態
DWORD                   g_firstTapTick = 0;
int                     g_tapCount = 0;

// 円ジェスチャ状態
std::vector<POINT>      g_path;                   // 軌跡点列
bool                    g_rbtnDown = false;   // 右ボタン押下フラグ

//========================= ユーティリティ =========================//
// yyMMdd を作成(例:251103)
std::wstring MakeYYMMDD() {
    SYSTEMTIME st{}; GetLocalTime(&st);
    wchar_t buf[16];
    swprintf_s(buf, L"%02d%02d%02d", st.wYear % 100, st.wMonth, st.wDay);
    return buf;
}

// 文字列をクリップボード(Unicode)へ
bool CopyToClipboard(const std::wstring& w) {
    if (!OpenClipboard(nullptr)) return false;
    EmptyClipboard();
    const SIZE_T bytes = (w.size() + 1) * sizeof(wchar_t);
    HGLOBAL h = GlobalAlloc(GMEM_MOVEABLE, bytes);
    if (!h) { CloseClipboard(); return false; }
    void* p = GlobalLock(h);
    if (!p) { GlobalFree(h); CloseClipboard(); return false; }
    memcpy(p, w.c_str(), bytes);
    GlobalUnlock(h);
    SetClipboardData(CF_UNICODETEXT, h); // 以後はシステム管理
    CloseClipboard();
    return true;
}

// 簡易距離・角度
inline double Dist(double x1, double y1, double x2, double y2) {
    const double dx = x2 - x1, dy = y2 - y1;
    return std::sqrt(dx * dx + dy * dy);
}
inline double Angle(double x1, double y1, double x2, double y2) {
    return std::atan2(y2 - y1, x2 - x1);
}

//========================= OSD(半透明無音フィードバック) =========================//
// OSDは「自分のWndProcタイマーで自壊」させる(他スレDestroyによる消滅不具合を避ける)
static LRESULT CALLBACK OSDWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
    switch (msg) {
    case WM_CREATE:
        SetTimer(hWnd, 1, OSD_LIFETIME_MS, nullptr); // 寿命タイマー
        return 0;
    case WM_TIMER:
        if (wParam == 1) {
            KillTimer(hWnd, 1);
            DestroyWindow(hWnd); // 自スレッドで安全に破棄
        }
        return 0;
    case WM_PAINT: {
        PAINTSTRUCT ps;
        HDC dc = BeginPaint(hWnd, &ps);
        RECT rc; GetClientRect(hWnd, &rc);

        // 背景(白系)+枠線
        HBRUSH br = CreateSolidBrush(RGB(250, 250, 250));
        FillRect(dc, &rc, br);
        DeleteObject(br);
        FrameRect(dc, &rc, (HBRUSH)GetStockObject(GRAY_BRUSH));

        // テキスト
        SetBkMode(dc, TRANSPARENT);
        DrawTextW(dc, L"コピーしました", -1, &rc,
            DT_CENTER | DT_VCENTER | DT_SINGLELINE);
        EndPaint(hWnd, &ps);
        return 0;
    }
    default:
        return DefWindowProcW(hWnd, msg, wParam, lParam);
    }
}

// 画面右上あたりに小窓を0.9秒だけ出す(フォーカスは奪わない)
void ShowOSDQuick() {
    static ATOM a = 0;
    if (!a) {
        WNDCLASSW wc{};
        wc.lpfnWndProc = OSDWndProc;
        wc.hInstance = GetModuleHandleW(nullptr);
        wc.lpszClassName = kOSDClass;
        wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
        a = RegisterClassW(&wc);
    }
    const int x = GetSystemMetrics(SM_CXSCREEN) - (OSD_W + 20);
    const int y = 40;

    HWND wnd = CreateWindowExW(
        WS_EX_TOPMOST | WS_EX_TOOLWINDOW | WS_EX_LAYERED | WS_EX_NOACTIVATE,
        kOSDClass, L"", WS_POPUP,
        x, y, OSD_W, OSD_H,
        nullptr, nullptr, GetModuleHandleW(nullptr), nullptr);
    SetLayeredWindowAttributes(wnd, 0, OSD_ALPHA, LWA_ALPHA);
    ShowWindow(wnd, SW_SHOWNA);
    UpdateWindow(wnd);
}

//========================= コア動作(コピー+無音通知) =========================//
void FireCopy() {
    const DWORD now = GetTickCount();
    if (now - g_lastFire.load() < FIRE_GUARD_MS) return; // 連発ガード
    g_lastFire.store(now);

    const std::wstring s = MakeYYMMDD();
    if (CopyToClipboard(s)) {
        ShowOSDQuick(); // 無音で視覚的フィードバック
    }
}

//========================= 円ジェスチャ判定 =========================//
bool IsCircleGesture(const std::vector<POINT>& pts) {
    if ((int)pts.size() < MIN_POINTS) return false;

    // 総距離
    double len = 0.0;
    for (size_t i = 1; i < pts.size(); ++i)
        len += Dist(pts[i - 1].x, pts[i - 1].y, pts[i].x, pts[i].y);
    if (len < MIN_PATH_LEN) return false;

    // 重心
    double cx = 0.0, cy = 0.0;
    for (const auto& p : pts) { cx += p.x; cy += p.y; }
    cx /= pts.size(); cy /= pts.size();

    // 半径分布(円らしさ)
    std::vector<double> rs; rs.reserve(pts.size());
    for (const auto& p : pts) rs.push_back(Dist(cx, cy, (double)p.x, (double)p.y));
    double mean = 0.0; for (double r : rs) mean += r; mean /= rs.size();
    if (mean < 10.0) return false; // 小さすぎる円はノイズ扱い
    double var = 0.0; for (double r : rs) { const double d = r - mean; var += d * d; } var /= rs.size();
    const double relStd = std::sqrt(var) / mean;
    if (relStd > MAX_REL_RADIUS_STD) return false;

    // 累積回転角
    const double PI = std::numbers::pi_v<double>;
    double sumAng = 0.0;
    for (size_t i = 1; i < pts.size(); ++i) {
        const double a1 = Angle(cx, cy, pts[i - 1].x, pts[i - 1].y);
        const double a2 = Angle(cx, cy, pts[i].x, pts[i].y);
        double d = a2 - a1;
        // [-pi, pi]へ正規化
        while (d > PI) d -= 2 * PI;
        while (d < -PI) d += 2 * PI;
        sumAng += d;
    }
    if (std::fabs(sumAng) < MIN_SWEEP_RAD) return false;

    // 長さも十分(概ね円周の6割以上)ならOK(粗チェック)
    const double approxCirc = 2 * PI * mean * 0.6;
    if (len < approxCirc) return false;

    return true;
}

//========================= 低レベルマウスフック =========================//
LRESULT CALLBACK MouseLLProc(int code, WPARAM wp, LPARAM lp) {
    if (code == HC_ACTION) {
        const MSLLHOOKSTRUCT* e = reinterpret_cast<MSLLHOOKSTRUCT*>(lp);
        switch (wp) {
        case WM_RBUTTONDOWN: {
            // 5連打カウント
            const DWORD now = GetTickCount();
            if (g_firstTapTick == 0 || (now - g_firstTapTick) > TAP_WINDOW_MS) {
                g_firstTapTick = now; g_tapCount = 1;
            } else {
                if (++g_tapCount >= TAP_COUNT_TARGET) {
                    g_firstTapTick = 0; g_tapCount = 0;
                    FireCopy();
                }
            }
            // 円ジェスチャ準備
            g_rbtnDown = true;
            g_path.clear();
            g_path.push_back(e->pt);
            break;
        }
        case WM_MOUSEMOVE:
            if (g_rbtnDown) g_path.push_back(e->pt);
            break;
        case WM_RBUTTONUP:
            if (g_rbtnDown) {
                g_rbtnDown = false;
                if (IsCircleGesture(g_path)) FireCopy();
                g_path.clear();
            }
            break;
        default: break;
        }
    }
    return CallNextHookEx(g_hMouseLL, code, wp, lp);
}

//========================= タスクトレイ:アイコン&メニュー =========================//
// アイコンの追加(起動時)
void TrayAdd(HWND hwnd) {
    g_nid = {};
    g_nid.cbSize = sizeof(g_nid);
    g_nid.hWnd = hwnd;
    g_nid.uID = 1;
    g_nid.uFlags = NIF_MESSAGE | NIF_ICON | NIF_TIP;
    g_nid.uCallbackMessage = WMAPP_TRAYICON;
    g_nid.hIcon = LoadIcon(nullptr, IDI_INFORMATION);
    lstrcpynW(g_nid.szTip, L"日付コピー(左クリック=コピー / 右クリック=メニュー)", _countof(g_nid.szTip));
    Shell_NotifyIconW(NIM_ADD, &g_nid);
}

// アイコン削除(終了時)
void TrayDelete() {
    if (g_nid.cbSize) {
        Shell_NotifyIconW(NIM_DELETE, &g_nid);
        g_nid = {};
    }
}

// 右クリックメニューをその場に表示
void TrayShowContextMenu(HWND hwnd) {
    POINT pt; GetCursorPos(&pt);
    HMENU hMenu = CreatePopupMenu();
    if (hMenu) {
        // メニュー構築
        AppendMenuW(hMenu, MF_STRING, ID_TRAY_COPY, L"YYMMDD");
        AppendMenuW(hMenu, MF_STRING, ID_TRAY_ABOUT, L"バージョン情報    mk 2025 ChatGPT");
        AppendMenuW(hMenu, MF_SEPARATOR, 0, nullptr);
        AppendMenuW(hMenu, MF_STRING, ID_TRAY_EXIT, L"終了");

        // トレイメニューはフォアグラウンドで出さないと閉じ挙動が乱れる
        SetForegroundWindow(hwnd);
        TrackPopupMenu(hMenu, TPM_RIGHTBUTTON, pt.x, pt.y, 0, hwnd, nullptr);
        DestroyMenu(hMenu);
    }
}

//========================= メイン隠しウィンドウ(メッセージ拠点) =========================//
//サブシステムを WINDOWS に変更(最も確実)
//MSVC のプロジェクト設定 → Linker → System → Subsystem = Windows

LRESULT CALLBACK MainWndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
    switch (msg) {
    case WM_CREATE: {
        // 低レベルマウスフック開始
        g_hMouseLL = SetWindowsHookExW(WH_MOUSE_LL, MouseLLProc, GetModuleHandleW(nullptr), 0);
        // トレイアイコン追加
        TrayAdd(hWnd);
        return 0;
    }
    case WMAPP_TRAYICON: {
        // 通知領域からのイベント
        switch (LOWORD(lParam)) {
        case WM_LBUTTONUP:
        case WM_LBUTTONDBLCLK:
            // 左クリック=即コピー
            FireCopy();
            break;
        case WM_RBUTTONUP:
        case WM_CONTEXTMENU:
            // 右クリック=メニュー展開
            TrayShowContextMenu(hWnd);
            break;
        default: break;
        }
        return 0;
    }
    case WM_COMMAND: {
        // トレイメニュー項目
        switch (LOWORD(wParam)) {
        case ID_TRAY_COPY:
            FireCopy();
            break;
        case ID_TRAY_ABOUT:
            // 無音で情報を出したいが、簡易にはMessageBox(音は鳴らない)
            MessageBoxW(hWnd, L"mk 2025 ChatGPT", L"バージョン情報", MB_OK | MB_TOPMOST);
            break;
        case ID_TRAY_EXIT:
            PostQuitMessage(0);
            break;
        default: break;
        }
        return 0;
    }
    case WM_QUERYENDSESSION:
        // OSシャットダウン/ログオフ開始 → OKを返して後始末(WM_ENDSESSIONへ続く)
        return TRUE;
    case WM_ENDSESSION:
        if (wParam) {
            // セッション終了確定:ここで後始末
            if (g_hMouseLL) { UnhookWindowsHookEx(g_hMouseLL); g_hMouseLL = nullptr; }
            TrayDelete();
        }
        return 0;
    case WM_DESTROY:
        // 通常終了時の後始末
        if (g_hMouseLL) { UnhookWindowsHookEx(g_hMouseLL); g_hMouseLL = nullptr; }
        TrayDelete();
        PostQuitMessage(0);
        return 0;
    default:
        return DefWindowProcW(hWnd, msg, wParam, lParam);
    }
}

//========================= エントリポイント(/SUBSYSTEM:WINDOWS) =========================//
int APIENTRY wWinMain(HINSTANCE hInst, HINSTANCE, LPWSTR, int) {
    // メイン(非表示)ウィンドウを 1つ作り、そこにフック/トレイ/OSD等を集約
    WNDCLASSW wc{};
    wc.lpfnWndProc = MainWndProc;
    wc.hInstance = hInst;
    wc.lpszClassName = kMainWndClass;
    wc.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    RegisterClassW(&wc);

    HWND hwnd = CreateWindowExW(
        0, kMainWndClass, L"", WS_OVERLAPPEDWINDOW,
        CW_USEDEFAULT, CW_USEDEFAULT, 240, 120,
        nullptr, nullptr, hInst, nullptr);

    // 完全非表示で常駐
    ShowWindow(hwnd, SW_HIDE);

    // メッセージループ(終了=PostQuitMessage)
    MSG msg;
    while (GetMessageW(&msg, nullptr, 0, 0)) {
        TranslateMessage(&msg);
        DispatchMessageW(&msg);
    }
    return (int)msg.wParam;
}

 

Gemini覚書

 

C = A + B を式テンプレートで書くには?

 

C = A + B」のような記述を式テンプレートで実現する場合、直接「C=A; C+=B;」のように分解して書くわけではありません。式テンプレートの目的は、A+B という式そのものを、その場で計算するのではなく、計算方法を記述したオブジェクトとして表現することにあります。

非常に簡略化された例で見てみましょう。ここでは、2つのベクトルを加算するケースを考えます。

 

template<typename T, size_t N>
class Vector {
public:
    T data[N];

    // コンストラクタなど省略...

    // 演算子+のオーバーロード(式テンプレートの核)
    // 戻り値の型がポイント!Vector<T, N> ではなく、式を表す型を返す
    template<typename OtherVector>
    VectorSum<Vector, OtherVector> operator+(const OtherVector& other) const {
        return VectorSum<Vector, OtherVector>(*this, other);
    }

    // 代入演算子(ここで実際の計算が走る)
    template<typename Expr>
    Vector& operator=(const Expr& expr) {
        for (size_t i = 0; i < N; ++i) {
            data[i] = expr[i]; // expr[i] が A[i] + B[i] を評価する
        }
        return *this;
    }

    // 式オブジェクトから値を取得するためのアクセス演算子
    // これが「遅延評価」の仕組みの肝
    T operator[](size_t i) const {
        // この Vector は計算済みデータを持つので、そのまま返す
        return data[i];
    }
};

// ベクトルの和を表す式オブジェクトのクラス
// これは A+B の「計算のレシピ」を持つ
template<typename LhsVector, typename RhsVector>
class VectorSum {
public:
    const LhsVector& lhs;
    const RhsVector& rhs;

    VectorSum(const LhsVector& l, const RhsVector& r) : lhs(l), rhs(r) {}

    // []演算子でアクセスがあったときに初めて計算を実行
    // 例: C[i] = (A+B)[i] の (A+B)[i] の部分
    auto operator[](size_t i) const {
        return lhs[i] + rhs[i]; // ここで実際に A[i] + B[i] が計算される
    }
    // サイズを返すための型エイリアスやメソッドも必要
    // static constexpr size_t size = LhsVector::size; など
};

// 実際の使用例
int main() {
    Vector<double, 3> A = {1.0, 2.0, 3.0};
    Vector<double, 3> B = {4.0, 5.0, 6.0};
    Vector<double, 3> C;

    C = A + B; // ここがポイント!

    // Cが計算された後、C.dataは {5.0, 7.0, 9.0} となる
    // for (size_t i = 0; i < 3; ++i) {
    //     std::cout << C.data[i] << std::endl;
    // }
    return 0;
}
 

この例の肝は以下の点です。

  1. Vector::operator+ の戻り値: Vector 型を直接返さず、VectorSum という式を表すオブジェクトを返しています。この VectorSum オブジェクトは、AB への参照を持ち、「AB を足し合わせる」という計算のレシピを保持しています。この時点ではまだ実際の加算は行われていません。

  2. Vector::operator= の実装: C = A + B= 演算子が呼ばれた際に、右辺の (A + B) が先ほどの VectorSum オブジェクトになります。この operator= の中でループを回し、expr[i](この場合は VectorSum オブジェクトの operator[])を呼び出すことで、初めて A[i] + B[i] の計算が実行され、その結果が C.data[i] に直接代入されます。

 

なぜ「単一のループで計算を行うことができ、より効率的になる可能性」があるのか?

 

上記の例では、C = A + B という式全体が、Vector::operator= 内の単一のループで処理されています。

もし式テンプレートを使わない場合、C = A + B は以下のように処理されることが多いでしょう(一般的な operator+ の実装を想定)。

// 従来のVectorクラス(簡易版)
template<typename T, size_t N>
class TraditionalVector {
public:
    T data[N];
    // コンストラクタなど省略...

    // 演算子+のオーバーロード(中間オブジェクトを生成)
    TraditionalVector operator+(const TraditionalVector& other) const {
        TraditionalVector result; // 1. 中間オブジェクトの生成!
        for (size_t i = 0; i < N; ++i) {
            result.data[i] = data[i] + other.data[i]; // 2. 最初のループ
        }
        return result; // 3. 中間オブジェクトを返す
    }
    // 代入演算子(コピーコンストラクタ経由で呼ばれることも)
    TraditionalVector& operator=(const TraditionalVector& other) {
        // 4. ここで中間オブジェクトの内容をCにコピー
        for (size_t i = 0; i < N; ++i) {
            data[i] = other.data[i];
        }
        return *this;
    }
};

// 従来のやり方での使用例
// TraditionalVector<double, 3> A, B, C;
// C = A + B;
 

この従来の方式では:

  1. A + B の計算のために、一時的な TraditionalVector オブジェクト (result) が生成されます。これはメモリの確保や初期化のオーバーヘッドになります。

  2. A + B の計算のために一度目のループが走ります。

  3. その一時オブジェクトが Cコピーされます。これにも二度目のループが走ることがあり、さらにメモリコピーのオーバーヘッドが発生します。

一方、式テンプレートを使った場合は:

  • A + B の時点では計算を行わず、計算方法を表す軽量なオブジェクトVectorSum)を生成するだけです。

  • C = (A + B) の代入演算子内で、A[i] + B[i] の計算と C[i] への代入を単一のループ内で同時に行います。

これにより、中間オブジェクトの生成と、それに伴うメモリ割り当て・コピーのオーバーヘッド、そしてループの複数回の実行を削減できるため、効率が向上します。特に大規模な行列やベクトルを扱う場合、この差は顕著になります。

 

式テンプレートはコンパイラへの「命令文」のようなブラックボックスか?

 

「式テンプレート風に書くと、コンパイラが式テンプレートを認識して、機械語を吐く一種の命令文のようなブラックボックスでしょうか?」というご質問ですが、半分正解で半分は違います。

  • 「一種の命令文のようなブラックボックス」ではない:式テンプレートは、C++の標準的なテンプレートと演算子オーバーロードの機能を使って実装されています。コンパイラが「式テンプレート」という特別な構文を認識しているわけではありません。コンパイラは、単にテンプレートのインスタンス化ルールと、ユーザーが定義した演算子のオーバーロードのルールに従って、コードを生成しているだけです。

  • 「コンパイラが認識して機械語を吐く」という点では近い:しかし、結果としてコンパイラは、上記で説明したような中間オブジェクトの生成を省き、単一の効率的なループに「展開された」機械語を生成します。これは、プログラマが手書きで書くような、最適化されたループ(例:for (size_t i = 0; i < N; ++i) { C.data[i] = A.data[i] + B.data[i]; })に相当するコードを、C = A + B というより自然な構文で書けるようになる、という点で「コンパイラに対する高度な指示」と捉えることもできます。

つまり、式テンプレートは、コンパイラの通常のメカニズムを巧みに利用して、開発者が意図する高度な最適化(遅延評価とループフュージョンなど)を、より高いレベルの抽象度で記述できるようにするデザインパターンと言えます。


この説明で、式テンプレートの実装と最適化の理屈が少しでもクリアになれば幸いです。式テンプレートは強力ですが、実装は複雑でデバッグも難しいため、通常はBoost.uBLASのような既存のライブラリを利用するのが一般的です。

覚書 引用 Gemini

ニューラルネットワークの台頭:遺伝的アルゴリズムからの変遷とその要因
1. はじめに
遺伝的アルゴリズム(遺伝的アルゴリズム)とニューラルネットワーク(ニューラルネット)は、人工知能と機械学習の分野において重要なアプローチとして発展してきました。遺伝的アルゴリズムは、生物の自然選択のプロセスに着想を得たヒューリスティック探索および最適化技術であり、遺伝学と進化の原理を利用して候補となる解決策を反復的に改善します 。一方、ニューラルネットワークは、人間の脳のニューロンに似た相互接続されたノードを持つ計算システムであり、アルゴリズムを使用して生のデータ内の隠れたパターンと相関関係を認識し、それらをクラスタリングおよび分類し、時間とともに継続的に学習および改善することができます 。ユーザーの観察にあるように、現在ではニューラルネットワークが多くの分野で優位性を確立し、遺伝的アルゴリズムを凌駕するようになっています。本レポートでは、この優位性の変遷の歴史的背景と、その要因となった主要な要素について探ります。
2. 遺伝的アルゴリズムの簡略な歴史
遺伝的アルゴリズムの初期の開発と基礎概念は、1960年代にジョン・ホランドによって提唱されました 。これは、進化計算と人工知能の分野における重要な進歩を示しました 。彼の著書「自然および人工システムの適応」(1975年)によって、1970年代初頭には広く知られるようになりました 。ダーウィンの進化論に触発された遺伝的アルゴリズムは 、シミュレーションベースのアプローチを用いて最適または満足のいく解決策を生成することを目的としています 。
遺伝的アルゴリズムの中核となる原理は、自然選択、交叉(組み換え)、突然変異です。自然選択は、より適応した個体がより高い確率で繁殖する「適者生存」の概念に基づいています 。交叉は、二つの親個体(解決策)の遺伝物質を組み合わせて、新しい子孫(解決策)を生成するプロセスです 。突然変異は、遺伝物質にランダムな変化を導入し、探索空間の新しい領域を探求するために多様性を生み出します 。これらの原理により、遺伝的アルゴリズムは広範囲の潜在的な解決策を探求することが可能になり、局所的な最適解にとらわれることなく、グローバルな探索能力を提供します。
遺伝的アルゴリズムは、当初から様々な分野で有望な結果を示しました。最適化問題では、与えられた制約の下で最良の解決策を見つけるために使用され 、経路計画、生産スケジューリング、リソース割り当てなどがその例です 。探索問題では、大規模で複雑な探索空間において質の高い解決策を見つけるために活用されました 。機械学習においては、特徴選択、ハイパーパラメータ調整、学習モデルの進化などに応用されました 。その他、工学設計、バイオインフォマティクス、ロボティクス、ゲーム理論など、多岐にわたる領域でその可能性が示唆されました 。初期の多様な分野での成功は、遺伝的アルゴリズムが一般的な最適化および探索技術としての汎用性を示唆し、当初の熱意を高める要因となりました。
時間の経過とともに、遺伝的アルゴリズムは進化し、多くのバリエーションが開発されました。エンコーディングスキーム(二進数、順列、値ベース、木構造など)の開発 、選択技術(ルーレットホイール、トーナメント、エリート選択など)の導入 、交叉および突然変異演算子(一点交叉、二点交叉、一様交叉、ビット反転、ガウス突然変異など)の探求 、そして、実数値GA、多目的GA、並列GA、ハイブリッドGAなどの派生型が登場しました 。これらの継続的な研究開発は、特定の問題特性に対処し、性能を向上させるために、基本的なGAフレームワークの様々な強化と適応をもたらしました。これらのバリエーションは、限界を克服し、アルゴリズムの有効性を高めることを目的としていました。
3. ニューラルネットワークの簡略な歴史
ニューラルネットワークの初期の概念化とパーセプトロンの開発は、1943年にウォーレン・マカロックとウォルター・ピッツによって、ニューロンがどのように機能するかという研究に基づいて行われました 。最初の訓練可能なニューラルネットワークであるパーセプトロンは、1957年にフランク・ローゼンブラットによって実証され、データから学習して二値分類を行うことができました 。
パーセプトロンが人間の知能を模倣する可能性に対する初期の興奮は大きかったものの 、1969年にマービン・ミンスキーとシーモア・パパートが著書「パーセプトロン」で指摘したように、特に単層ネットワークではXORのような非線形分離可能な問題を解決できないという基本的な限界が明らかになりました 。ミンスキーとパパートの研究は、研究への関心と資金提供の減少につながり、1970年代の最初の「AIの冬」の一因となりました 。この時期には、伝統的なフォン・ノイマン型アーキテクチャが計算分野を席巻していました 。初期のNNの限界と代替となる計算パラダイムの台頭は、NN研究の一時的な衰退につながりました。
しかし、1980年代には、バックプロパゲーション(誤差逆伝播法)アルゴリズムが普及したことで、ニューラルネットワークは復活を遂げました 。バックプロパゲーションは、多層ニューラルネットワークの効率的な訓練を可能にし、パーセプトロンのいくつかの限界を克服しました 。このアルゴリズムの開発と普及は、NNがより複雑なパターンを学習することを可能にし、この分野への関心を再燃させる転換点となりました。
その後、主要なニューラルネットワークアーキテクチャが開発されました。畳み込みニューラルネットワーク(CNN)は、1980年代後半にヤン・ルカンによって導入され、畳み込み層とプーリング層を使用することで、特に画像認識において非常に効果的であることが示されました 。リカレントニューラルネットワーク(RNN)は、フィードバックループを持つことで、時系列データのような逐次的なデータを処理するように設計されており、「記憶」を持つことができます 。LSTM(Long Short-Term Memory)ネットワークは、RNNにおける勾配消失問題を解決しました 。これらの特殊なアーキテクチャの開発により、ニューラルネットワークは様々な種類のデータとタスクを効果的に処理できるようになり、その応用範囲が大幅に拡大しました。
2010年代以降、「ディープラーニング革命」が起こりました。これは主に、コンピュータゲーム業界向けに開発されたグラフィックスプロセッシングユニット(GPU)の処理能力の向上  と、大規模なデータセット(ビッグデータ)の利用可能性の増加  によって推進されました。2012年のImageNetコンペティションでアレックスネットが優勝したことは、ディープ畳み込みニューラルネットワークの力を示し、画期的な出来事となりました 。その後、Transformerのような高度なアーキテクチャの開発により、自然言語処理が大きく進歩しました 。強力なハードウェア、膨大なデータセット、革新的なアーキテクチャの融合により、ニューラルネットワークの能力は飛躍的に向上し、ディープラーニングの時代が到来しました。
4. ニューラルネットワークの台頭とその優位性に寄与する要因
ニューラルネットワークが初期の限界を克服したことは、その台頭と優位性の重要な要因の一つです。バックプロパゲーションの導入により、浅いネットワークの限界に対処し、深いネットワークの訓練が可能になりました 。ReLU(Rectified Linear Unit)のような改善された活性化関数の導入は、勾配消失問題を軽減し、より深いネットワークの訓練を可能にしました 。多層(「深い」)ネットワークアーキテクチャの能力は、階層的な特徴抽出を可能にし、生のデータから複雑なパターンを学習することを可能にしました 。ドロップアウト 、バッチ正規化 、より良い重み初期化法などのより効果的な訓練方法論は、訓練プロセスを改善し、より堅牢で正確なモデルにつながりました 。
データの役割もまた、ニューラルネットワークの優位性を高める上で不可欠でした。インターネット、ソーシャルメディア、様々なアプリケーションによって生成されるデータの爆発的な増加は、ディープラーニングモデルを効果的に訓練するために必要な大量のラベル付きデータを提供しました 。ImageNet  は、画像認識を大幅に進歩させた大規模なラベル付きデータセットの代表的な例です。「データ駆動型学習」の原則が中心となり、より大規模で多様なデータセットが、ニューラルネットワークの汎化能力と堅牢性を向上させました 。
計算能力の進歩も重要な役割を果たしました。当初グラフィックスレンダリング用に設計されたグラフィックスプロセッシングユニット(GPU)の開発と普及は、並列処理に非常に効果的であることが証明されました。これは、大規模なニューラルネットワークの訓練に不可欠です 。GPUは、訓練時間を数日から数時間に大幅に短縮しました 。Tensor Processing Units(TPU)やその他の特殊なハードウェアの登場は、ニューラルネットワークの訓練と推論をさらに加速させました 。
ブレークスルーとなったアプリケーションと成功事例も、ニューラルネットワークの優位性を確固たるものにしました。アレックスネットやその後のアーキテクチャによって示されたように、ディープラーニングモデルは画像認識タスクにおいて人間レベルの性能を達成しました 。アプリケーションには、ソーシャルメディアのタグ付け、医療画像分析、自動運転などが含まれます 。RNN、LSTM、特にTransformer(BERT、GPTなど)のようなアーキテクチャは、機械翻訳、テキスト生成、感情分析などのNLPタスクにおいて大きな進歩を遂げました 。ディープラーニングモデルは、音声認識システムの精度と使いやすさを大幅に向上させました 。AlphaGoのようなゲームプレイング 、医療診断 、自動運転車  などの分野での成功は、ニューラルネットワークの優位性をさらに強固なものにしました。
一方、遺伝的アルゴリズムは、いくつかの固有の限界と課題に直面しており、それが特定の複雑な問題空間においてニューラルネットワークほど効果的にスケールアップし、性能を発揮することを妨げてきました。GAは、特に探索空間が広い複雑な問題では、最適な解決策に収束するのに時間がかかることがあります 。アルゴリズムが探索空間全体を探索する前に、準最適な解決策に早期に収束してしまう可能性もあります 。GAの性能は、パラメータ(個体数、突然変異率、交叉率)の選択に非常に敏感であり、最適な設定を見つけるには時間がかかり、試行錯誤が必要となる場合があります 。GAは、特に突然変異にさらされる要素の数が多い場合、問題の複雑さに対してうまくスケールしません 。目的とする結果を正確に反映する適切な適合度関数と、効率的な解決策の表現を設計することは、複雑な現実世界の問題では困難な場合があります 。大規模な個体群に対して多数の世代にわたって適合度関数を評価することは、特に単一の評価に多大なリソースを必要とする問題では、計算コストが高くなる可能性があります 。
5. 現在の状況と将来の展望
現在の状況を比較すると、遺伝的アルゴリズムはグローバル探索、非滑らかな目的関数の処理、並列化において強みを発揮します 。一方、収束速度、スケーラビリティ、パラメータ調整、複雑な問題に対する解釈可能性においては課題が残ります 。対照的に、ニューラルネットワークは、複雑なパターンの学習、非構造化データの処理、様々なタスクでの高い精度達成において強みを発揮します 。しかし、解釈可能性(ブラックボックス性)、大量のデータ要件、計算コストにおいては課題があります 。
ニューラルネットワークが多くの複雑なパターン認識タスクで優位に立っている一方で、遺伝的アルゴリズムは、特に目的関数が容易に微分可能でない場合や探索空間が非常に複雑な場合に、最適化問題において依然として価値があります。遺伝的アルゴリズムは、勾配ベースの手法が適用できない非滑らかまたは不連続な目的関数を持つ問題 、グローバル探索が重要な非常に大規模で複雑な探索空間の探求 、解釈可能性が良好な解決策を見つけることよりも重要でない最適化問題 、進化的設計や創造的な応用 、ニューラルネットワークを含む機械学習モデルのハイパーパラメータ最適化  など、特定のシナリオでは依然として好ましいアプローチとなる可能性があります。
遺伝的アルゴリズムとニューラルネットワークの両方の強みを活かすために、両方の技術を組み合わせたハイブリッドアプローチの探求も進んでいます 。例えば、ニューラルアーキテクチャの探索やハイパーパラメータの調整にGAを使用するなどです 。
将来の展望としては、両分野ともに研究が継続されており、それぞれの限界に対処するための進歩が期待されます。GAに関しては、収束とスケーラビリティの改善に向けた取り組み  が行われています。ニューラルネットワークに関しては、解釈可能性の向上、データ要件の削減、堅牢性の強化に焦点が当てられています 。
6. 結論
遺伝的アルゴリズムとニューラルネットワークは、それぞれ独自の歴史を歩んできました。ホランドによるGAの研究や、バックプロパゲーションとディープラーニングの開発といった主要な出来事が、両分野の発展を形作ってきました。現在、ニューラルネットワークが優位性を確立している主な要因は、初期の限界の克服、ビッグデータの利用可能性、計算能力(特にGPU)の進歩、そして様々な複雑なAIタスクにおける目覚ましい成功事例です。結論として、ニューラルネットワークは現在支配的な地位を占めていますが、遺伝的アルゴリズムは依然として価値のある応用分野を持っており、将来の進歩は、両方のパラダイムのユニークな強みを活用する新たな役割とハイブリッドアプローチにつながる可能性があります。
遺伝的アルゴリズムとニューラルネットワークの主な強みと弱みの比較
| 特徴 | 遺伝的アルゴリズム | ニューラルネットワーク |
|---|---|---|
| 強み | グローバル探索能力、非滑らかな目的関数の処理、並列化が容易、局所最適解に陥りにくい | 複雑なパターンの学習、非構造化データの処理、様々なタスクで高い精度、特徴量エンジニアリングが不要 |
| 弱み | 収束が遅い、スケーラビリティに課題、パラメータ調整が難しい、複雑な問題に対する解釈可能性が低い、計算コストが高い | 解釈可能性が低い(ブラックボックス性)、大量のデータが必要、計算コストが高い、過学習しやすい |
| 得意な領域 | 最適化問題(特に目的関数が微分不可能または探索空間が複雑な場合)、進化的設計、ハイパーパラメータ最適化 | パターン認識(画像、音声、テキストなど)、予測モデリング、教師あり学習タスク |

ローカル変数での最適化

引用 ChatGPT

if (idx > 0) {
    const auto prevCut = dGCut(idx - 1);
    const auto currCut = dGCut(idx);
    const auto prevTei = viBBwariCut_[idx - 1];

    if (currCut == prevCut && prevTei == i) {
        continue;
    }
}

一見、配列を外に出しただけですが、条件文の配列呼び出しがネックとなる意味ですか?
最適化上、うまくしてくれないのか?

ローカル変数にする意味は何か?
ご質問要旨:

const auto prevCut = dGCut(idx - 1);
const auto currCut = dGCut(idx);

これは単に関数/配列を外に出しただけで、意味があるのか?
回答:意味は大きくあります。キャッシュ・レジスタ活用のためです。
理由1:関数呼び出しやインデックス演算が繰り返されるのを防ぐ

    dGCut(...) が単純な std::vector でも operator[] の境界チェックあり(デバッグ時)

    operator() なら内部に計算処理がある可能性大

    auto でローカル変数に落とすことで1回だけ評価すれば済む

🔸 理由2:コンパイラがレジスタに載せやすい

    ローカル変数だと、GCCやClangは積極的にレジスタ割り当てしてくれる

    一方、dGCut(idx) を2回書くと、同じ値なのに2回フェッチされる可能性がある

🔧 まとめ

    読み出しや計算の重複排除

    レジスタ割当最適化を助ける

    可読性も上がる

これは明確に意味がある最適化です。

プログラミングの覚書

引用 Gemini


ごもっともなご懸念ですね。for文の外でローカル変数を宣言することは、確かにコンパイラの最適化に影響を与える可能性があります。

一般的に、最新の最適化コンパイラは非常に賢く、for文内で繰り返し宣言されるローカル変数を認識し、実際には一度だけメモリを割り当てるように最適化することが多いです。そのため、単純にfor文の外に出したからといって、必ずしも最適化が促進されるとは限りませんし、むしろ逆効果になることもあります。

for文内で変数を宣言する主な利点は、その変数のスコープがfor文内に限定されることです。これにより、以下の点が期待できます。

 * 可読性の向上: 変数が使用される範囲が明確になるため、コードが理解しやすくなります。

 * 名前空間の汚染の防止: 不要なグローバルスコープやより広いスコープへの変数の露出を防ぎ、意図しない変数名の衝突を避けることができます。

 * コンパイラの最適化の促進: 変数の生存期間が限定されるため、コンパイラがより積極的にレジスタ割り当てなどの最適化を行える可能性があります。

一方、for文の外で変数を宣言する場合、その変数はfor文の終了後も有効なままです。これにより、コンパイラは変数の生存期間が長くなることを考慮する必要があるため、最適化の機会が減少する可能性があります。例えば、

 * レジスタ割り当ての制約: 変数がより長い期間生存するため、コンパイラがその変数を特定のレジスタに保持できる期間が短くなる可能性があります。

 * 不要なメモリ確保: for文の実行後も変数がメモリを占有し続ける可能性があります。

実際に違いが見られるかどうかは、コンパイラの最適化レベル、コードの内容、そしてターゲットとなるアーキテクチャに大きく依存します。

以下に簡単な例を示します。

// 例1: for文内で宣言

for (int i = 0; i < 100; ++i) {

    int temp = i * 2;

    // tempを使った処理

}


// 例2: for文の外で宣言

int temp;

for (int i = 0; i < 100; ++i) {

    temp = i * 2;

    // tempを使った処理

}


多くの最適化コンパイラは、例1の temp がfor文内でのみ使用されることを認識し、ループの各イテレーションで temp のための新しいメモリ割り当てを行わず、実際にはレジスタなどを効率的に再利用する可能性があります。例2の場合でも、コンパイラは temp がループ内でどのように使用されるかを分析し、同様の最適化を適用しようとするかもしれませんが、変数のスコープが広いため、最適化の自由度が狭まる可能性は否定できません。

結論として、for文内のローカル変数を安易に外に出すことは、必ずしも最適化に繋がるとは言えず、むしろコードの可読性を損なう可能性があります。 最新のコンパイラは賢いため、まずは自然なスコープで変数を宣言し、コンパイラに最適化を任せるのが良いでしょう。

もし、特定のループで性能上の問題が発生している場合は、コンパイラの最適化レポートなどを確認し、変数のスコープが最適化の妨げになっているかどうかを調査することを推奨します。その上で、必要であればプロファイリングを行い、実際に性能が向上するかどうかを確認しながらコードを修正していくのが安全なアプローチです。

C++乱数の覚書

引用 ChatGPT

時間的基準はXorShift32を基準としsは疑似タイムである。

アルゴリズム別:相対速度比較(更新版)

アルゴリズム 状態サイズ 周期 統計品質 実行時間(相対) 備考
XorShift32 32ビット 2³² - 1 1.0 s (基準) 最速、品質は低い
XorShift32 + カウンタ再シード 32ビット 擬似無限 やや改善 1.3 ~ 1.5 s 周期の突破、統計特性わずかに向上
XorShift128+ 128ビット 2¹²⁸ - 1 1.5 ~ 2.0 s 64bitアーキテクチャに適した構造
Xoroshiro128++ 128ビット 2¹²⁸ - 1 2.0 ~ 2.5 s 推奨アルゴリズムの一つ、実装も比較的簡単
Xoshiro256++ 256ビット 2²⁵⁶ - 1 非常に高 2.5 ~ 3.0 s 64bit向け、現在推奨される高性能PRNG
Xoshiro512++ 512ビット 2⁵¹² - 1 超高 3.5 ~ 4.0 s 高精度・高周期用途に適す、状態サイズが大きいため遅め
std::mt19937 19937ビット 2¹⁹⁹³⁷ - 1 非常に高 10 ~ 15 s 非常に長い周期、高品質、速度は遅い(ルックアップテーブル型)

LPで、整数部を次の枝に採用するとありますが、どの程度の実数を採用していますか?


■「LP解の整数部を採用して分枝」について



これは、「分枝限定法における分枝変数の選び方」の話です。以下で詳しく解説します。

■ 1. LP解の一部が実数(例:x₁ = 3.6)になる場合

このとき、そのノードではまだ整数制約が満たされていないので、次のような**分枝(branching)**を行います:

(例)LP緩和で x₁ = 3.6 のとき:

  → 子ノードA:x₁ ≤ 3

  → 子ノードB:x₁ ≥ 4

これは「床関数と天井関数で分割する」という基本手法です。

整数部(floor)とそれ以上の範囲を「2つのノード」として分けて探索します。





■ 2. 「LPの実数解を次の枝に採用する」とは?



これは、**分枝に使う変数の選び方(branching variable selection)**に関する文脈でよく登場します:


  • 通常、**最も実数部分が大きい変数(例:x = 3.5)**を選ぶ
  • なぜなら:そのような変数は**「整数になりにくく、最も曖昧」なので、早く分枝して確定させたい**






■ どの程度の実数を採用するのか?




→ この 0.001〜0.999 の範囲の値を持つ変数の中から、「どれを使うか」はヒューリスティック(手法次第)ですが、0.5付近が最も“ぶれ”が大きく好まれる傾向にあります。





■ 分枝変数の選び方(参考)



以下のような戦略が存在します:


  • 最も小数部分が0.5に近い変数(= “most fractional”)
  • 擬似コスト法(pseudo-cost branching):
    → 過去の分枝結果から、どの変数を分枝すると改善効果が高いか学習
  • 強制分枝法(strong branching):
    → 分枝前に仮にLPを解いて、改善効果が高い方を選ぶ(計算コスト高)






■ まとめ



  • LP解で整数でない変数は、床と天井で分枝される
  • 分枝変数の選び方は戦略によるが、**「0.5付近の値」**がよく選ばれる
  • 採用する実数値の基準は、「どれが最も“整数から遠いか”」が目安
  • より精緻なアルゴリズムでは、「効果が高そうな変数」を見極めるための統計的手法(擬似コスト法など)も用いられる



   探索ノードA
      |
    緩和(LP)解 = 95% (これ以上良くならない=下界)
      |
現在のベスト整数解 = 96%(=上界)

→ 95% < 96% → Aを枝刈り(探索の価値なし)

よくわかりました。現在の解が下界を超えた時点が枝切り発動ですね。

そしたら、さらに深く行っても改善しない事を保証するにはLPでなければ保証はなさそうですが、どうですか?


貪欲法では枝切りを促進され、その先の探索で見つかる可能性が、あるって理解でどうですか?

素晴らしい理解です、まさにその通りです。

以下に、あなたの問いを踏まえて明確にまとめます。





■ LP緩和と貪欲法の違い:枝切りの

保証力




● LP緩和の下界(理論的下限):



  • 連続緩和に基づく数学的な最適値(=厳密な下界)
  • よって、このノード以下でこれ以上良くなることはないと「保証」できる
  • 枝切りの条件が 理論的に正当化されている



→ 安心して pruning できる(例:95%が下界なら、そこから先で96%は出ない)





● 貪欲法(greedy)の下界:



  • 一般には「貪欲解=その場しのぎのヒューリスティック解」
  • 下界ではなく近似解であり、理論保証は基本的にない
  • ただし:
    • 経験的に高速
    • 多くの無駄な探索を早く除外できる
    • でも、枝切りの判断に誤りを含む可能性がある

→ 誤って“良い解がある枝”を切ってしまうリスクがある

OpenBLASとEigenについての考察

引用 ChatGPT

 

  1. ライセンス比較(商用利用、個人利用、ライブラリ作者の責任、ライセンス表記、変更・再配布、ソースコード公開義務など)

  2. 上記内容を踏まえた総合的な比較

  3. C++環境での代表的な数値計算(Ax=bの求解、行列演算、CG法、内点法、LP、配列操作)における速度差の比較やベンチマーク考察

調査が完了次第、比較表や明確な結論を含めてご報告します。

 

OpenBLASとEigenのライセンス比較

項目 OpenBLAS (BSD-3-Clause) Eigen (MPL 2.0)
商用利用 許可(制限なし)opensource.org 許可(制限なし)eigen.tuxfamily.org
個人利用 許可(制限なし)opensource.org 許可(制限なし)eigen.tuxfamily.org
表記義務 ソース/バイナリ再配布時に著作権表示と免責条項を含める必要があるopensource.org ライセンス文書を含める必要がある(各ファイルにSPDX識別子やヘッダを付与)mozilla.orgeigen.tuxfamily.org
改変・再配布 許可(変更内容の開示義務なし)opensource.org 許可。ただしEigenライブラリ自身のソースに修正を加えて再配布する場合、その修正部分をMPLで開示する必要があるmozilla.org
ソース開示 必須ではない MPL対象ファイル(Eigenヘッダ)を配布する際に修正を開示mozilla.org
責任明示(免責) 「AS IS」「無保証」で提供。著作権者/貢献者は一切の責任を負わない(免責条項)opensource.org 同様に無保証・免責(MPL条項に含まれる)
その他 コントリビュータ名や開発者名を製品名や宣伝に使ってはならない(推奨・エンドースメント禁止)opensource.org ファイル単位の弱いコピーレフト。Eigen自体を改変しない限り、利用ソフトウェアのソース公開義務は課されないmozilla.orgeigen.tuxfamily.org
  • 許可範囲: OpenBLASはBSD-3-Clauseで、商用・個人利用ともにほぼ制限なく自由に使えるopensource.org。EigenはMPL v2.0でこちらも商用・個人利用が認められており、閉源ソフトでもEigenを組み込んで配布できる(自社コードの開示義務はない)eigen.tuxfamily.org

  • 表記義務: OpenBLASではソース・バイナリの再配布時にライセンス文を付記すればよくopensource.org、Eigenでも配布パッケージにMPLライセンス文を含める必要があるmozilla.orgeigen.tuxfamily.org

  • 改変時の義務: BSDでは改変したコードを公開する義務はなく自由度が高いopensource.org。対してMPLでは、Eigenヘッダ(ライセンス対象ファイル)に加えた変更はMPLの下で開示しなければならない(ライセンス部分の再公開義務)mozilla.org。ただし新規に自作したファイルやEigenに依存しない部分には公開義務は及ばないmozilla.org

  • 責任・保証: いずれも無保証(“AS IS”)を明記し、著作権者・開発者は責任を負わない旨が定められているopensource.org

  • 注意点: MPLはBSD/MITよりファイル単位でコピーレフト性があるため、企業によってはLGPL/GPLと混同して警戒される場合があるforum.kde.org。OpenBLAS/BSDは更に緩やかで、企業開発ではBSDの方を好むケースもあるforum.kde.org

用途別の適合性

  • 商用アプリ開発: どちらも商用で利用可能だが、ライセンス条項に注意が必要。OpenBLAS (BSD) はほとんど制限がなく、ソフトウェアへの組み込みや再配布が容易opensource.org。Eigen (MPL) も閉源アプリに使えるが、Eigen本体を改変した場合はその修正を公開する義務があるmozilla.orgeigen.tuxfamily.org。企業が「オープンソース依存」を避けたがる場合、BSDライセンスのほうが安心感が高いことがあるforum.kde.org

  • 研究開発: 研究用途ではどちらも問題なく使用できる。Eigenはヘッダのみのテンプレートライブラリで利用が簡便なため、試作やプロトタイプに使われることが多い。OpenBLASは最適化されたBLAS/LAPACK実装なので、大規模な数値計算で性能を重視する研究開発に適している。研究目的であればライセンス開示の影響は少ないため、実装しやすいほうを選んでよい。

  • 再配布用ライブラリ開発: 自身でライブラリを配布する場合、OpenBLAS版はBSD条件(著作権表示の保持など)さえ守ればほぼ自由に組み込めるopensource.org。Eigen版の場合も、Eigenヘッダを同梱して配布できるが、配布時にはMPLライセンス表記を含める必要がある。Eigenヘッダを改変していなければ公開義務はないため、配布条件自体はそれほど厳しくはないmozilla.orgeigen.tuxfamily.org。つまりプロプライエタリな再配布ではOpenBLASの方がライセンス上の自由度が高く、Eigenは「改変分だけ開示で済む」弱いコピーレフトである。

性能比較

  • 連立一次方程式 (Ax = b) の解法: OpenBLASはLAPACKを含み、DGESVなどの最適化された解法ルーチンが利用可能で、大規模行列の解法性能は極めて高いnetlib.org。EigenはLU分解やQR分解による直接解法を提供するが、非常に大きな系ではLAPACKほど高速とは限らない。一般には、OpenBLAS+LAPACKのほうが大規模系には有利であり、非常に高速な解が期待できる。一方、系の規模や反復ソルバーの選択により差は変動する。参考までに、LAPACKベンチマークでは最適化BLAS(LinuxではATLAS)を用いて計測が行われておりnetlib.org、OpenBLAS版でも同等かそれ以上の性能が見込める。

  • 行列演算 (特に行列積): 大規模行列積ではOpenBLASが優位であることが知られているblog.csdn.netblog.csdn.net。例えばあるベンチマーク(単一スレッド)では、行列サイズ1000でOpenBLASが0.2373秒、Eigenが0.3179秒(OpenBLASが約25%速い)という結果が得られたblog.csdn.net。行列サイズが増えるほど差は大きくなり、サイズ5000ではOpenBLASが29.07秒、Eigenが37.68秒とOpenBLASが高速だったblog.csdn.net。逆に小規模行列(数百サイズ以下)では、Eigenのテンプレート最適化によりMKL等を上回る例も報告されているdiscourse.julialang.org。複数コア利用時は、OpenBLASもEigenもマルチスレッド化できるが、一般にOpenBLASやMKLといったBLASライブラリを併用するほうが性能面で有利とされるscicomp.stackexchange.com

    行列サイズ Eigen (単一スレッド) OpenBLAS (単一スレッド)
    1000×1000 0.3179 秒 0.2373 秒 blog.csdn.net
    3000×3000 8.2807 秒 6.2979 秒 blog.csdn.net
    5000×5000 37.6755 秒 29.0723 秒 blog.csdn.net
    上記はCSDNブログのベンチマーク結果(単一スレッド)より。OpenBLASが一貫して高速であることがわかるblog.csdn.net    
  • 共役勾配法 (CG): Eigenには疎行列(および密行列)向けの共役勾配ソルバーEigen::ConjugateGradientが用意されているeigen.tuxfamily.org。これにより自己随伴行列に対する反復解法が可能で、内部でベクトル演算を行う。OpenBLAS自体にはCGの高級APIはないため、CGを利用する場合はBLAS(axpyやdot)を用いた自前実装か、別ライブラリ(EigenやIntel MKLのスパース機能、PETScなど)を組み合わせることになる。性能面では、CGは前処理や疎行列の特性に大きく依存するため、ライブラリ選択以上にアルゴリズム設計が重要である。

  • 内点法・線形計画法 (LP): いずれのライブラリも直接的な内点法ソルバーや線形計画ソルバーを含んでいない。これらを利用する場合はGLPKやCPLEX、Gurobi、OSQPなどの専用ソルバを用い、それらの内部でBLAS(OpenBLAS)やEigenの線形代数機能が使われることがある。従って純粋な比較対象外だが、Eigenの行列操作機能やOpenBLASの高速BLASは、独自実装の数値演算部分で有利に働く可能性がある。

  • 配列の行・列の合計: 素朴なループ計算またはBLASのSDOT(全て1のベクトルとの内積)等で実装される簡単な操作であり、ライブラリ依存性は低い。一般にどちらもメモリアクセス速度にほぼ左右され、大きな性能差はない。Eigenでは.rowwise().sum() などの組み込み関数、OpenBLASでは低レベルのループもしくはBLAS関数で実装可能である。

  • 配列のコピー: 完全にメモリ転送の処理であり、memcpy程度の違いしかないため、EigenもOpenBLASも同等である。ライブラリ固有の最適化は特にないため、どちらを使ってもほぼ差が生じない。

参考: 行列演算のベンチマーク結果blog.csdn.netdiscourse.julialang.org、Eigen公式ドキュメントeigen.tuxfamily.org、また実際のユーザ議論scicomp.stackexchange.comdiscourse.julialang.orgなどを基にまとめた。OpenBLASはGotoBLAS2系のチューニングによってピーク性能に近づいており、特に大規模行列では優れるblog.csdn.net。一方Eigenはテンプレート式評価による組み合わせ最適化が強みで、条件によっては高速になる場合があるdiscourse.julialang.orgscicomp.stackexchange.com

#if 1   // 1にするとコメント解除 0でコメント化除
//*  ( /* コメント化 )( //* コメント解除 )
                cout << "(" << dGTei(i) << ":";
                for (size_t j = 0; j < veTeis[i].size(); ++j) {
                    cout << veTeis[i][j];
                    if (j != veTeis[i].size() - 1) cout << ",";
                }
                cout << ") ";
                //*/
#endif