MUM-T 유무인복합 분산 전자지원(ES)/전자공격(EA) 협동 적응 빔성형 널 스티어링(Null-Steering) 서보 아키텍처 (.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.ElectronicWarfare
{
    /// <summary>
    /// MUM-T 전자공격(EA) 적응 빔성형 아군 보호 널 스티어링(Null-Steering) 서보
    /// GC 제로 할당 ref struct 및 AVX-256 SIMD 가속화
    /// </summary>
    public ref struct SwarmEaNullSteeringServo
    {
        private readonly ReadOnlySpan<float> _steeringPhases;   // 주 조향 방향 위상 (rad)
        private readonly ReadOnlySpan<float> _nullPhases;       // 아군 보호 널 방향 위상 (rad)
        private readonly Span<float> _realWeights;              // 산출된 복소 가중치 실수부
        private readonly Span<float> _imagWeights;              // 산출된 복소 가중치 허수부
        private readonly Span<float> _synthesizedPower;         // 합성 빔 전력 프로파일

        private readonly float _nullCancellationGain; // 널 상쇄 게인
        private readonly float _normScale;            // 정규화 계수

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public SwarmEaNullSteeringServo(
            ReadOnlySpan<float> steeringPhases,
            ReadOnlySpan<float> nullPhases,
            Span<float> realWeights,
            Span<float> imagWeights,
            Span<float> synthesizedPower,
            float nullCancellationGain = 0.88f,
            float normScale = 0.125f) // 1/8 for 8-element
        {
            _steeringPhases = steeringPhases;
            _nullPhases = nullPhases;
            _realWeights = realWeights;
            _imagWeights = imagWeights;
            _synthesizedPower = synthesizedPower;
            _nullCancellationGain = nullCancellationGain;
            _normScale = normScale;
        }

        /// <summary>
        /// 8개 배열 소자의 복소 가중치를 SIMD 병렬 연산하여 널 형성 및 빔 전력 산출
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
        public void ComputeNullSteeringWeights()
        {
            int length = _steeringPhases.Length;
            int simdLength = length - (length % 8);

            Vector256<float> vGain = Vector256.Create(_nullCancellationGain);
            Vector256<float> vScale = Vector256.Create(_normScale);

            int i = 0;
            if (Avx2.IsSupported)
            {
                for (; i < simdLength; i += 8)
                {
                    Vector256<float> vPs = Vector256.Create(MemoryMarshal.Cast<float, Vector256<float>>(_steeringPhases.Slice(i, 8))[0]);
                    Vector256<float> vPn = Vector256.Create(MemoryMarshal.Cast<float, Vector256<float>>(_nullPhases.Slice(i, 8))[0]);

                    // 테일러 2차 근사 cos(x) ~ 1 - x^2/2, sin(x) ~ x - x^3/6
                    Vector256<float> vPsSq = Avx.Multiply(vPs, vPs);
                    Vector256<float> vCosPs = Avx.Subtract(Vector256.Create(1.0f), Avx.Multiply(vPsSq, Vector256.Create(0.5f)));
                    Vector256<float> vSinPs = Avx.Subtract(vPs, Avx.Multiply(Avx.Multiply(vPsSq, vPs), Vector256.Create(0.166667f)));

                    Vector256<float> vPnSq = Avx.Multiply(vPn, vPn);
                    Vector256<float> vCosPn = Avx.Subtract(Vector256.Create(1.0f), Avx.Multiply(vPnSq, Vector256.Create(0.5f)));
                    Vector256<float> vSinPn = Avx.Subtract(vPn, Avx.Multiply(Avx.Multiply(vPnSq, vPn), Vector256.Create(0.166667f)));

                    // 널 상쇄 가중치: W = (a(theta_s) - gain * a(theta_n)) * scale
                    Vector256<float> vRealW = Avx.Multiply(Avx.Subtract(vCosPs, Avx.Multiply(vGain, vCosPn)), vScale);
                    Vector256<float> vImagW = Avx.Multiply(Avx.Subtract(vSinPs, Avx.Multiply(vGain, vSinPn)), vScale);

                    // 소자 전력: |W|^2
                    Vector256<float> vPwr = Avx.Add(Avx.Multiply(vRealW, vRealW), Avx.Multiply(vImagW, vImagW));

                    vRealW.CopyTo(_realWeights.Slice(i, 8));
                    vImagW.CopyTo(_imagWeights.Slice(i, 8));
                    vPwr.CopyTo(_synthesizedPower.Slice(i, 8));
                }
            }

            for (; i < length; i++)
            {
                float cosPs = MathF.Cos(_steeringPhases[i]);
                float sinPs = MathF.Sin(_steeringPhases[i]);
                float cosPn = MathF.Cos(_nullPhases[i]);
                float sinPn = MathF.Sin(_nullPhases[i]);

                float rw = (cosPs - (_nullCancellationGain * cosPn)) * _normScale;
                float iw = (sinPs - (_nullCancellationGain * sinPn)) * _normScale;
                _realWeights[i] = rw;
                _imagWeights[i] = iw;
                _synthesizedPower[i] = (rw * rw) + (iw * iw);
            }
        }
    }
}