차기 이지스 구축함 및 합동 작전 광역 통합방공(IAMD) 협동교전능력(CEC) 다중 분산 센서-투-슈터 위협 평가 및 무기 할당(TEWA) 분산 옥션(Auction) 헝가리안 매칭 0-Alloc C# 엔진

using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Intrinsics;
using System.Runtime.Intrinsics.X86;

namespace ZeliDesk.Defense.Tewa
{
    [StructLayout(LayoutKind.Sequential, Pack = 16)]
    public struct TargetThreatProfile
    {
        public Vector256<float> Kinematics;  // [x, y, z, 0, vx, vy, vz, 0] (m, m/s)
        public float TimeToImpact;           // 초
        public float ClosingSpeed;           // m/s
        public float ThreatScore;            // 0.0 ~ 100.0
        public int TargetId;
    }

    [StructLayout(LayoutKind.Sequential, Pack = 16)]
    public struct InterceptorWeapon
    {
        public Vector256<float> LauncherPos; // [x, y, z, 0, 0, 0, 0, 0]
        public float MaxRange;               // m
        public float PkBase;                 // 명중률 (0.85 등)
        public int WeaponId;
        public int AssignedTargetId;
    }

    public sealed class DistributedTewaAuctionEngine
    {
        private const int MaxAgents = 16;
        private const int MaxTargets = 16;
        private const float Epsilon = 0.01f;

        [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
        public void SolveTewaAuction(
            ReadOnlySpan<InterceptorWeapon> weapons,
            ReadOnlySpan<TargetThreatProfile> targets,
            Span<int> outAssignments)
        {
            int nW = Math.Min(weapons.Length, MaxAgents);
            int nT = Math.Min(targets.Length, MaxTargets);

            // 0-Alloc 인메모리 스택 버퍼 할당
            Span<float> costMatrix = stackalloc float[MaxAgents * MaxTargets];
            Span<float> targetPrices = stackalloc float[MaxTargets];
            Span<int> targetOwners = stackalloc int[MaxTargets];
            Span<int> weaponAssignments = stackalloc int[MaxAgents];

            targetPrices.Clear();
            targetOwners.Fill(-1);
            weaponAssignments.Fill(-1);

            // 1. 센서-투-슈터 효용 비용 행렬 계산: C_ij = ThreatScore_j * P_k(i, j)
            for (int i = 0; i < nW; i++)
            {
                float wx = weapons[i].LauncherPos.GetElement(0);
                float wy = weapons[i].LauncherPos.GetElement(1);
                float wz = weapons[i].LauncherPos.GetElement(2);

                for (int j = 0; j < nT; j++)
                {
                    float tx = targets[j].Kinematics.GetElement(0);
                    float ty = targets[j].Kinematics.GetElement(1);
                    float tz = targets[j].Kinematics.GetElement(2);

                    float dx = tx - wx;
                    float dy = ty - wy;
                    float dz = tz - wz;
                    float dist = MathF.Sqrt(dx * dx + dy * dy + dz * dz + 1e-3f);

                    // 유효 사거리 내일 때 유효 확률 계산
                    float pk = (dist <= weapons[i].MaxRange) ? weapons[i].PkBase * (1.0f - dist / (weapons[i].MaxRange * 1.5f)) : 0.0f;
                    pk = Math.Clamp(pk, 0.0f, 0.99f);

                    costMatrix[i * MaxTargets + j] = targets[j].ThreatScore * pk;
                }
            }

            // 2. 분산 옥션(Auction Algorithm) 반복 수렴 루프
            int unassignedCount = nW;
            int maxIterations = 200;
            int iter = 0;

            while (unassignedCount > 0 && iter++ < maxIterations)
            {
                for (int i = 0; i < nW; i++)
                {
                    if (weaponAssignments[i] != -1) continue;

                    // 최고 효용 가치(Best Value) 및 차순위 가치(Second Best) 탐색
                    float bestValue = -1e9f;
                    float secondBestValue = -1e9f;
                    int bestTarget = -1;

                    for (int j = 0; j < nT; j++)
                    {
                        float value = costMatrix[i * MaxTargets + j] - targetPrices[j];
                        if (value > bestValue)
                        {
                            secondBestValue = bestValue;
                            bestValue = value;
                            bestTarget = j;
                        }
                        else if (value > secondBestValue)
                        {
                            secondBestValue = value;
                        }
                    }

                    if (bestTarget != -1 && bestValue > 0.0f)
                    {
                        // 입찰 가격 증분 계산
                        float bidIncrement = (bestValue - secondBestValue) + Epsilon;
                        targetPrices[bestTarget] += bidIncrement;

                        // 기존 소유자 퇴출 및 신규 소유권 갱신
                        int prevOwner = targetOwners[bestTarget];
                        if (prevOwner != -1)
                        {
                            weaponAssignments[prevOwner] = -1;
                            unassignedCount++;
                        }

                        targetOwners[bestTarget] = i;
                        weaponAssignments[i] = bestTarget;
                        unassignedCount--;
                    }
                }
            }

            // 결과 복사 (0-Alloc)
            for (int i = 0; i < nW; i++)
            {
                outAssignments[i] = weaponAssignments[i];
            }
        }
    }
}