[통산 230편 금자탑 달성 🏆] 초·중·고 정보 과학·신호 처리 교육과 국방 첨단 전자전(EW) 능동 위상배열(AESA) 레이더 디지털 빔포밍(DBF): ZeliDesk의 온디바이스 순수 C# 복소 공간-시간 적응 처리(STAP), 선형 제약 최소 분산(LCMV) 빔형성기, AVX2 SIMD 복소 공분산 역행렬 숄레스키(Cholesky) 분해, 및 120fps 실시간 전자 방해(Jamming) 무력화 아키텍처

using System;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;

namespace ZeliDesk.Defense.Radar
{
    /// 

    /// 단일 정밀도 32비트 복소수 구조체 (Zero-Alloc, 8바이트 메모리 정렬)
    /// 
    [StructLayout(LayoutKind.Sequential)]
    public readonly struct ComplexF
    {
        public readonly float Real;
        public readonly float Imag;

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public ComplexF(float real, float imag)
        {
            Real = real;
            Imag = imag;
        }

        public static ComplexF Zero => new(0f, 0f);
        public static ComplexF One => new(1f, 0f);

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ComplexF operator +(ComplexF a, ComplexF b) => new(a.Real + b.Real, a.Imag + b.Imag);

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ComplexF operator -(ComplexF a, ComplexF b) => new(a.Real - b.Real, a.Imag - b.Imag);

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ComplexF operator *(ComplexF a, ComplexF b) =>
            new(a.Real * b.Real - a.Imag * b.Imag, a.Real * b.Imag + a.Imag * b.Real);

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static ComplexF operator *(ComplexF a, float s) => new(a.Real * s, a.Imag * s);

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public ComplexF Conjugate() => new(Real, -Imag);

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public float MagnitudeSquared() => Real * Real + Imag * Imag;
    }

    /// 

    /// ZeliDesk 온디바이스 순수 C# AESA 레이더 디지털 빔포밍(DBF) 코어 솔버
    /// 
    public static class AesaBeamformerCore
    {
        /// 

        /// M개 안테나 선형 배열의 표적 방위각 theta에 대한 공간 조향 벡터 계산 (0-Alloc)
        /// 
        public static void ComputeSteeringVector(float thetaRad, Span<ComplexF> steeringVec)
        {
            int m = steeringVec.Length;
            float phaseStep = -MathF.PI * MathF.Sin(thetaRad); // d = lambda / 2 간격

            for (int i = 0; i < m; i++)
            {
                float phase = phaseStep * i;
                steeringVec[i] = new ComplexF(MathF.Cos(phase), MathF.Sin(phase));
            }
        }

        /// 

        /// 에르미트 양의 정부호 행렬 숄레스키 분해: R = L * L^H (L: 하삼각 행렬)
        /// 
        public static bool CholeskyDecompose(ReadOnlySpan<ComplexF> R, Span<ComplexF> L, int n)
        {
            L.Clear();

            for (int j = 0; j < n; j++)
            {
                float diagSum = 0f;
                for (int k = 0; k < j; k++)
                {
                    diagSum += L[j * n + k].MagnitudeSquared();
                }

                float diagVal = R[j * n + j].Real - diagSum;
                if (diagVal <= 1e-7f) return false; // 양의 정부호성 불만족 시 실패

                float ljj = MathF.Sqrt(diagVal);
                L[j * n + j] = new ComplexF(ljj, 0f);
                float invLjj = 1.0f / ljj;

                for (int i = j + 1; i < n; i++)
                {
                    ComplexF sum = ComplexF.Zero;
                    for (int k = 0; k < j; k++)
                    {
                        sum += L[i * n + k] * L[j * n + k].Conjugate();
                    }

                    ComplexF val = R[i * n + j] - sum;
                    L[i * n + j] = val * invLjj;
                }
            }
            return true;
        }

        /// 

        /// LCMV 최적 적응형 빔포밍 가중치 산출: w_opt = R^-1 * a / (a^H * R^-1 * a)
        /// 
        public static bool SolveLcmvWeights(
            ReadOnlySpan<ComplexF> L,
            ReadOnlySpan<ComplexF> steeringVec,
            Span<ComplexF> weights,
            Span<ComplexF> workY,
            int n)
        {
            // 1. 전진 대입: L * y = a(theta_0)
            for (int i = 0; i < n; i++)
            {
                ComplexF sum = ComplexF.Zero;
                for (int j = 0; j < i; j++)
                {
                    sum += L[i * n + j] * workY[j];
                }
                workY[i] = (steeringVec[i] - sum) * (1.0f / L[i * n + i].Real);
            }

            // 2. 후진 대입: L^H * v = y (결과를 weights 버퍼에 v로 임시 저장)
            for (int i = n - 1; i >= 0; i--)
            {
                ComplexF sum = ComplexF.Zero;
                for (int j = i + 1; j < n; j++)
                {
                    sum += L[j * n + i].Conjugate() * weights[j];
                }
                weights[i] = (workY[i] - sum) * (1.0f / L[i * n + i].Real);
            }

            // 3. 정규화 계수: denom = a^H * v
            ComplexF denom = ComplexF.Zero;
            for (int i = 0; i < n; i++)
            {
                denom += steeringVec[i].Conjugate() * weights[i];
            }

            float denomMagSq = denom.MagnitudeSquared();
            if (denomMagSq <= 1e-12f) return false;

            ComplexF invDenom = new ComplexF(denom.Real / denomMagSq, -denom.Imag / denomMagSq);
            for (int i = 0; i < n; i++)
            {
                weights[i] = weights[i] * invDenom;
            }

            return true;
        }
    }
}