초·중·고 정보 과학(행렬 분해·콜레스키 역행렬·복소수 신호 처리)·물리(전자기파 도플러 효과·위상 간섭·클러터) 교육과 국방 기무/공군 E-737 조기경보통제기 및 KF-21 능동위상배열(AESA) 레이더 지상이동표적식별(GMTI)과 시공간 적응처리(STAP, Space-Time Adaptive Processing): ZeliDesk의 온디바이스 순수 C# 실시간 2D 각도-도플러 공분산 행렬 수치 모델링, 0-Alloc SIMD 콜레스키(Cholesky) 분해 최적 가중치 가중 적분기, 및 저고도 스텔스 순항미사일 탐지 엔진 아키텍처

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

namespace ZeliDesk.AesaStapRadar
{
    /// <summary>
    /// 단정밀도 복소수 구조체 (8바이트 하드웨어 레지스터 맞춤)
    /// </summary>
    [StructLayout(LayoutKind.Sequential)]
    public struct Complex32
    {
        public float Real;
        public float Imag;

        public Complex32(float real, float imag)
        {
            Real = real;
            Imag = imag;
        }

        public static Complex32 FromPolar(float r, float theta)
            => new Complex32(r * MathF.Cos(theta), r * MathF.Sin(theta));

        public float SqrMagnitude() => Real * Real + Imag * Imag;

        public static Complex32 operator +(Complex32 a, Complex32 b)
            => new Complex32(a.Real + b.Real, a.Imag + b.Imag);

        public static Complex32 operator -(Complex32 a, Complex32 b)
            => new Complex32(a.Real - b.Real, a.Imag - b.Imag);

        public static Complex32 operator *(Complex32 a, Complex32 b)
            => new Complex32(a.Real * b.Real - a.Imag * b.Imag, a.Real * b.Imag + a.Imag * b.Real);

        public static Complex32 operator *(Complex32 a, float s)
            => new Complex32(a.Real * s, a.Imag * s);

        public Complex32 Conjugate() => new Complex32(Real, -Imag);
    }

    /// <summary>
    /// 0-Alloc AVX2 SIMD 시공간 적응처리(STAP) 클러터 필터링 엔진
    /// </summary>
    public sealed class AesaStapEngine
    {
        private readonly int _numElements; // 공간 안테나 소자 수 (N)
        private readonly int _numPulses;   // 시간 펄스 수 (M)
        private readonly int _dof;         // 총 시공간 자유도 (N * M)

        public AesaStapEngine(int numElements = 8, int numPulses = 4)
        {
            _numElements = numElements;
            _numPulses = numPulses;
            _dof = numElements * numPulses; // 32 DOF
        }

        /// <summary>
        /// 2D 시공간 조향 벡터 합성 (0-Alloc stackalloc)
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
        public void SynthesizeSteeringVector(float targetAngleRad, float normDopplerFreq, Span<Complex32> outputVector)
        {
            int idx = 0;
            for (int m = 0; m < _numPulses; m++)
            {
                float timePhase = 2.0f * MathF.PI * normDopplerFreq * m;
                for (int n = 0; n < _numElements; n++)
                {
                    float spacePhase = MathF.PI * MathF.Sin(targetAngleRad) * n;
                    float totalPhase = timePhase + spacePhase;
                    outputVector[idx++] = Complex32.FromPolar(1.0f, totalPhase);
                }
            }
        }

        /// <summary>
        /// 에르미트 양의 정부호 행렬의 0-Alloc 콜레스키 분해 (L * L^H = R)
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
        public static bool CholeskyDecompose(ReadOnlySpan<Complex32> R, Span<Complex32> L, int n)
        {
            L.Clear();

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

                float diagVal = R[j * n + j].Real - sumDiag;
                if (diagVal <= 1e-6f) return false; // 양의 정부호 아님

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

                for (int i = j + 1; i < n; i++)
                {
                    Complex32 sumOff = new Complex32(0f, 0f);
                    for (int k = 0; k < j; k++)
                    {
                        Complex32 lik = L[i * n + k];
                        Complex32 ljkConj = L[j * n + k].Conjugate();
                        sumOff = sumOff + (lik * ljkConj);
                    }

                    Complex32 diff = R[i * n + j] - sumOff;
                    L[i * n + j] = diff * invLjj;
                }
            }

            return true;
        }

        /// <summary>
        /// STAP 필터링을 통한 클러터 제거 후 표적 신호 추출 (0 Heap Allocation)
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
        public Complex32 FilterTargetSample(
            ReadOnlySpan<Complex32> inputCpiData,
            ReadOnlySpan<Complex32> L,
            ReadOnlySpan<Complex32> steeringVec,
            int n)
        {
            // Forward: L * y = v_t
            Span<Complex32> y = stackalloc Complex32[n];
            for (int i = 0; i < n; i++)
            {
                Complex32 sum = steeringVec[i];
                for (int k = 0; k < i; k++)
                {
                    sum = sum - (L[i * n + k] * y[k]);
                }
                y[i] = sum * (1.0f / L[i * n + i].Real);
            }

            // Back: L^H * w = y
            Span<Complex32> w = stackalloc Complex32[n];
            for (int i = n - 1; i >= 0; i--)
            {
                Complex32 sum = y[i];
                for (int k = i + 1; k < n; k++)
                {
                    sum = sum - (L[k * n + i].Conjugate() * w[k]);
                }
                w[i] = sum * (1.0f / L[i * n + i].Real);
            }

            // Inner product: output = w^H * x
            Complex32 output = new Complex32(0f, 0f);
            for (int i = 0; i < n; i++)
            {
                output = output + (w[i].Conjugate() * inputCpiData[i]);
            }

            return output;
        }
    }
}