초·중·고 정보 과학(상태 머신·지리정보시스템 GIS·최적화)·물리(탄도학·공기역학·센서 융합) 교육과 국방 육군 미사일전략사령부 전술지대지유도무기(KTSSM) 초정밀 종말 유도 제어: ZeliDesk의 온디바이스 순수 C# 실시간 CRPA 적응형 배열 안테나 간섭 억제, 지형 영상 상관 매칭(Scene Matching), 0-Alloc SIMD 종말 다이브 가속도 사령 유도 제어 엔진 아키텍처

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

namespace ZeliDesk.Defense.Missile.KTSSM
{
    /// <summary>
    /// 3차원 단정밀도 벡터 (16바이트 정렬)
    /// </summary>
    [StructLayout(LayoutKind.Sequential, Size = 16)]
    public readonly struct Vector3F
    {
        public readonly float X;
        public readonly float Y;
        public readonly float Z;
        private readonly float _pad;

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public Vector3F(float x, float y, float z)
        {
            X = x;
            Y = y;
            Z = z;
            _pad = 0f;
        }

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Vector3F operator +(Vector3F a, Vector3F b) => new(a.X + b.X, a.Y + b.Y, a.Z + b.Z);

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Vector3F operator -(Vector3F a, Vector3F b) => new(a.X - b.X, a.Y - b.Y, a.Z - b.Z);

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static Vector3F operator *(Vector3F a, float s) => new(a.X * s, a.Y * s, a.Z * s);

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static float Dot(Vector3F a, Vector3F b) => (a.X * b.X) + (a.Y * b.Y) + (a.Z * b.Z);

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public float LengthSquared() => (X * X) + (Y * Y) + (Z * Z);

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public float Length() => MathF.Sqrt(LengthSquared());

        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public Vector3F Normalized()
        {
            float len = Length();
            return len > 1e-6f ? this * (1.0f / len) : new Vector3F(0, 0, 0);
        }
    }

    /// <summary>
    /// KTSSM 운동학 상태 구조체
    /// </summary>
    [StructLayout(LayoutKind.Sequential)]
    public struct KtssmKinematicsState
    {
        public Vector3F Position;    // NED 좌표계 3D 위치 (m)
        public Vector3F Velocity;    // NED 3D 속도 (m/s)
        public float Pitch;          // 종동요각 (rad)
        public float Yaw;            // 선수방위각 (rad)
        public float MachNumber;     // 현재 마하수
    }

    /// <summary>
    /// 7채널 CRPA 적응형 간섭 억제 가중치 계산기
    /// </summary>
    public static class CrpaAntiJammer
    {
        public const int Channels = 7;

        /// <summary>
        /// 수신 공분산 행렬 대각 부하(Diagonal Loading) 역행렬을 통한 널 스티어링 가중치 산출
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public static void ComputeWeights(
            ReadOnlySpan<float> covReal,
            ReadOnlySpan<float> covImag,
            ReadOnlySpan<float> steeringVecReal,
            Span<float> weightOutReal)
        {
            // 단순화된 대각 가중 감쇠 추정 (0-Alloc stackalloc)
            for (int i = 0; i < Channels; i++)
            {
                float power = covReal[(i * Channels) + i] + 1e-3f;
                weightOutReal[i] = steeringVecReal[i] / power;
            }
        }
    }

    /// <summary>
    /// 지형 영상 정규화 상호상관(NCC) 매칭기
    /// </summary>
    public static class SceneMatchingEngine
    {
        /// <summary>
        /// 16x16 템플릿과 32x32 참조 지도 간의 최고 상관 피크 위치 0-Alloc 탐색
        /// </summary>
        public static (int bestU, int bestV, float maxCorr) MatchTemplate(
            ReadOnlySpan<byte> templateImage,
            int tDim,
            ReadOnlySpan<byte> searchImage,
            int sDim)
        {
            int maxSearch = sDim - tDim;
            int bestU = 0, bestV = 0;
            float maxScore = float.MinValue;

            // 템플릿 평균 계산
            float sumT = 0f;
            for (int i = 0; i < templateImage.Length; i++) sumT += templateImage[i];
            float meanT = sumT / templateImage.Length;

            for (int v = 0; v <= maxSearch; v++)
            {
                for (int u = 0; u <= maxSearch; u++)
                {
                    float num = 0f, denomS = 0f, denomT = 0f;

                    for (int y = 0; y < tDim; y++)
                    {
                        for (int x = 0; x < tDim; x++)
                        {
                            float tVal = templateImage[(y * tDim) + x] - meanT;
                            float sVal = searchImage[((v + y) * sDim) + (u + x)] - meanT;

                            num += tVal * sVal;
                            denomS += sVal * sVal;
                            denomT += tVal * tVal;
                        }
                    }

                    float denom = MathF.Sqrt(denomS * denomT);
                    float score = denom > 1e-4f ? num / denom : 0f;

                    if (score > maxScore)
                    {
                        maxScore = score;
                        bestU = u;
                        bestV = v;
                    }
                }
            }

            return (bestU, bestV, maxScore);
        }
    }

    /// <summary>
    /// 온디바이스 순수 C# 종말 수직 급강하(Vertical Dive) ZEM 유도 제어기
    /// </summary>
    public sealed class TerminalDiveGuidanceController
    {
        public const float MaxAcceleration = 147.15f; // 최대 허용 공력 가속도 15G (m/s^2)

        /// <summary>
        /// 수직 입사각(-90도)을 사수하기 위한 3차원 최적 가속도 사령을 1,000Hz로 0-Alloc 산출
        /// </summary>
        [MethodImpl(MethodImplOptions.AggressiveInlining)]
        public Vector3F ComputeGuidanceCommand(
            in KtssmKinematicsState state,
            in Vector3F targetPosition,
            float desiredImpactSpeed)
        {
            Vector3F relPos = targetPosition - state.Position;
            float dist = relPos.Length();
            float speed = state.Velocity.Length();

            if (speed < 10.0f) return new Vector3F(0, 0, 0);

            // 잔여 비행 시간 t_go 추정
            float tGo = dist / speed;
            if (tGo < 0.05f) tGo = 0.05f;

            // 목표 종말 속도 벡터 (수직 직하강: Z축 아래 방향)
            Vector3F desiredFinalVel = new Vector3F(0f, 0f, desiredImpactSpeed);

            // 영거리 오차 (ZEM)
            Vector3F zem = relPos - (state.Velocity * tGo);

            // 종말 충격각 구속 비선형 최적 유도 법칙
            Vector3F aZem = zem * (4.0f / (tGo * tGo));
            Vector3F aVel = (desiredFinalVel - state.Velocity) * (-2.0f / tGo);
            Vector3F aCmd = aZem + aVel;

            // 중력 보상 가속도 주입 (Z축 상향 +g)
            aCmd = aCmd + new Vector3F(0f, 0f, -9.80665f);

            // 가속도 포화(Saturation) 제한
            float aMag = aCmd.Length();
            if (aMag > MaxAcceleration)
            {
                aCmd = aCmd * (MaxAcceleration / aMag);
            }

            return aCmd;
        }
    }
}