MUM-T 극초음속 비행편대 상호 후류 충격파 간섭(Shock-Shock Interaction) 회피 능동 포메이션 제어 서보 아키텍처 (.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.Hypersonic
{
    /// <summary>
    /// MUM-T 극초음속 편대 충격파 상호 간섭(Edney IV) 회피 능동 서보
    /// GC 제로 할당 ref struct 및 AVX-256 SIMD 가속화
    /// </summary>
    public ref struct HypersonicFormationShockServo
    {
        private readonly ReadOnlySpan<float> _relativeDistX;     // 종방향 상대거리 DeltaX (m)
        private readonly ReadOnlySpan<float> _relativeDistY;     // 횡방향 상대거리 DeltaY (m)
        private readonly ReadOnlySpan<float> _relativeDistZ;     // 수직방향 상대거리 DeltaZ (m)
        private readonly Span<float> _shockClearanceMargins;     // 연산된 충격파 여유 마진 (m)
        private readonly Span<float> _lateralAvoidanceAccel;     // 횡방향 회피 가속도 지령 (m/s^2)

        private readonly float _shockAngleTan; // tan(beta)
        private readonly float _safeMargin;    // 최소 안전 이격거리 (m)
        private readonly float _repulsiveGain; // 회피 가속도 게인

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public HypersonicFormationShockServo(
            ReadOnlySpan<float> relativeDistX,
            ReadOnlySpan<float> relativeDistY,
            ReadOnlySpan<float> relativeDistZ,
            Span<float> shockClearanceMargins,
            Span<float> lateralAvoidanceAccel,
            float machNumber = 6.0f,
            float wedgeAngleDeg = 12.0f,
            float safeMargin = 8.5f,
            float repulsiveGain = 14.0f)
        {
            _relativeDistX = relativeDistX;
            _relativeDistY = relativeDistY;
            _relativeDistZ = relativeDistZ;
            _shockClearanceMargins = shockClearanceMargins;
            _lateralAvoidanceAccel = lateralAvoidanceAccel;

            // 마하 6 및 쐐기각 12도 기준 경사 충격파 각도 beta ~ 18.5도
            float betaRad = 18.5f * (MathF.PI / 180.0f);
            _shockAngleTan = MathF.Tan(betaRad);
            _safeMargin = safeMargin;
            _repulsiveGain = repulsiveGain;
        }

        /// <summary>
        /// 8대 무인기의 편대 상대위치를 SIMD 병렬 분석하여 충격파 회피 가속도 산출
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveOptimization)]
        public void ExecuteShockAvoidanceLoop()
        {
            int length = _relativeDistX.Length;
            int simdLength = length - (length % 8);

            Vector256<float> vTanBeta = Vector256.Create(_shockAngleTan);
            Vector256<float> vSafe = Vector256.Create(_safeMargin);
            Vector256<float> vGain = Vector256.Create(_repulsiveGain);
            Vector256<float> vZero = Vector256<float>.Zero;
            Vector256<float> vMaxAccel = Vector256.Create(45.0f); // 4.5 G 제한

            int i = 0;
            if (Avx2.IsSupported)
            {
                for (; i < simdLength; i += 8)
                {
                    Vector256<float> vDx = Vector256.Create(MemoryMarshal.Cast<float, Vector256<float>>(_relativeDistX.Slice(i, 8))[0]);
                    Vector256<float> vDy = Vector256.Create(MemoryMarshal.Cast<float, Vector256<float>>(_relativeDistY.Slice(i, 8))[0]);

                    // 선행기 충격파 반경: R_shock = DeltaX * tan(beta)
                    Vector256<float> vRshock = Avx.Multiply(vDx, vTanBeta);

                    // 횡방향 이탈 마진: Margin = |DeltaY| - R_shock
                    Vector256<float> vAbsDy = Avx.Max(vDy, Avx.Subtract(vZero, vDy));
                    Vector256<float> vMargin = Avx.Subtract(vAbsDy, vRshock);

                    // 위험 침범량: Breach = max(0, Safe - Margin)
                    Vector256<float> vBreach = Avx.Max(vZero, Avx.Subtract(vSafe, vMargin));

                    // 회피 가속도 지령 = Gain * Breach * sign(Dy)
                    Vector256<float> vSign = Avx.BlendVariable(
                        Vector256.Create(-1.0f),
                        Vector256.Create(1.0f),
                        Avx.CompareGreaterThanOrEqual(vDy, vZero)
                    );
                    Vector256<float> vAccel = Avx.Multiply(Avx.Multiply(vGain, vBreach), vSign);
                    Vector256<float> vClampedAccel = Avx.Min(vMaxAccel, Avx.Max(Avx.Subtract(vZero, vMaxAccel), vAccel));

                    vMargin.CopyTo(_shockClearanceMargins.Slice(i, 8));
                    vClampedAccel.CopyTo(_lateralAvoidanceAccel.Slice(i, 8));
                }
            }

            for (; i < length; i++)
            {
                float rshock = _relativeDistX[i] * _shockAngleTan;
                float absDy = MathF.Abs(_relativeDistY[i]);
                float margin = absDy - rshock;
                float breach = MathF.Max(0.0f, _safeMargin - margin);
                float sign = _relativeDistY[i] >= 0 ? 1.0f : -1.0f;
                float accel = Math.Clamp(_repulsiveGain * breach * sign, -45.0f, 45.0f);

                _shockClearanceMargins[i] = margin;
                _lateralAvoidanceAccel[i] = accel;
            }
        }
    }
}