MUM-T 유무인복합 초수평선(OTH) 대류권 산란통신(Troposcatter) 레이크 수신기 다중경로 위상합성 서보 아키텍처 (.NET 9 C# SIMD)

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

namespace ZeliDesk.Defense.TacticalCommunications
{
    /// <summary>
    /// 대류권 산란통신(Troposcatter) 레이크(Rake) 수신기 최대비 합성(MRC) 서보
    /// GC 제로 할당 ref struct 및 AVX-256 SIMD 가속화
    /// </summary>
    public ref struct TroposcatterRakeServo
    {
        private readonly ReadOnlySpan<float> _fingerReal;        // 핑거 수신 신호 실수부
        private readonly ReadOnlySpan<float> _fingerImag;        // 핑거 수신 신호 허수부
        private readonly ReadOnlySpan<float> _channelGainReal;   // 채널 추정치 실수부
        private readonly ReadOnlySpan<float> _channelGainImag;   // 채널 추정치 허수부
        private readonly Span<float> _mrcWeightedOutputs;        // MRC 가중 합성 성분
        private readonly Span<float> _fingerSnrEstimates;        // 채널별 추정 SNR

        private readonly float _noiseVariance; // 잡음 분산 sigma^2
        private readonly float _normFactor;    // 정규화 스케일

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public TroposcatterRakeServo(
            ReadOnlySpan<float> fingerReal,
            ReadOnlySpan<float> fingerImag,
            ReadOnlySpan<float> channelGainReal,
            ReadOnlySpan<float> channelGainImag,
            Span<float> mrcWeightedOutputs,
            Span<float> fingerSnrEstimates,
            float noiseVariance = 0.05f,
            float normFactor = 1.0f)
        {
            _fingerReal = fingerReal;
            _fingerImag = fingerImag;
            _channelGainReal = channelGainReal;
            _channelGainImag = channelGainImag;
            _mrcWeightedOutputs = mrcWeightedOutputs;
            _fingerSnrEstimates = fingerSnrEstimates;
            _noiseVariance = noiseVariance;
            _normFactor = normFactor;
        }

        /// <summary>
        /// 8개 핑거 경로의 복소 곱셈 및 최대비 합성을 SIMD 병렬 연산
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
        public void ExecuteMrcCombiningLoop()
        {
            int length = _fingerReal.Length;
            int simdLength = length - (length % 8);

            Vector256<float> vNoise = Vector256.Create(_noiseVariance);
            Vector256<float> vScale = Vector256.Create(_normFactor);

            int i = 0;
            if (Avx2.IsSupported)
            {
                for (; i < simdLength; i += 8)
                {
                    Vector256<float> vRxR = Vector256.Create(MemoryMarshal.Cast<float, Vector256<float>>(_fingerReal.Slice(i, 8))[0]);
                    Vector256<float> vRxI = Vector256.Create(MemoryMarshal.Cast<float, Vector256<float>>(_fingerImag.Slice(i, 8))[0]);
                    Vector256<float> vHR = Vector256.Create(MemoryMarshal.Cast<float, Vector256<float>>(_channelGainReal.Slice(i, 8))[0]);
                    Vector256<float> vHI = Vector256.Create(MemoryMarshal.Cast<float, Vector256<float>>(_channelGainImag.Slice(i, 8))[0]);

                    // 복소 곱: Rx * H* = (RxR + j RxI) * (HR - j HI)
                    // 실수부: RxR * HR + RxI * HI
                    Vector256<float> vRePart = Avx.Add(Avx.Multiply(vRxR, vHR), Avx.Multiply(vRxI, vHI));

                    // 채널 전력: |H|^2 = HR^2 + HI^2
                    Vector256<float> vChanPwr = Avx.Add(Avx.Multiply(vHR, vHR), Avx.Multiply(vHI, vHI));

                    // SNR = |H|^2 / Noise
                    Vector256<float> vSnr = Avx.Divide(vChanPwr, vNoise);

                    // 가중 합성치 = RePart * Scale
                    Vector256<float> vOut = Avx.Multiply(vRePart, vScale);

                    vOut.CopyTo(_mrcWeightedOutputs.Slice(i, 8));
                    vSnr.CopyTo(_fingerSnrEstimates.Slice(i, 8));
                }
            }

            for (; i < length; i++)
            {
                float rePart = (_fingerReal[i] * _channelGainReal[i]) + (_fingerImag[i] * _channelGainImag[i]);
                float chanPwr = (_channelGainReal[i] * _channelGainReal[i]) + (_channelGainImag[i] * _channelGainImag[i]);
                _mrcWeightedOutputs[i] = rePart * _normFactor;
                _fingerSnrEstimates[i] = chanPwr / _noiseVariance;
            }
        }
    }
}