‫بررسی نوع جنریک Complex در دات‌نت 11

چکیده: محاسبات علمی و پردازش سیگنال همواره به بازنمایی دقیق و بهینهٔ اعداد مختلط وابسته بوده‌اند. در پلتفرم دات‌نت، ساختار سنتی System.Numerics.Complex دهه‌ها با مؤلفه‌های مبتنی بر ممیز شناور با دقت مضاعف (double یا ۶۴ بیتی) پیاده‌سازی شده بود؛ انتخابی مطمئن برای حفظ پایداری عددی، اما ناکارآمد در سناریوهایی که فشار حافظه یا توان محاسباتی سخت‌افزار نیازمند بازنمایی‌های سبک‌تر نظیر float (۳۲ بیتی) است. با معرفی و تکامل ریاضیات جنریک (Generic Math) در دات‌نت، معرفی ساختار جنریک Complex گامی مهم در جداسازی مفهوم ریاضی عدد مختلط از دقت پایه‌ای سخت‌افزاری آن به‌شمار می‌رود. این مقاله به بررسی ساختار درونی Complex، تحلیل موازنهٔ میان مصرف حافظه و خطای انباشت محاسباتی (Precision vs. Memory)، بررسی تأثیر پهنای باند حافظه و برداری‌سازی سخت‌افزاری (SIMD)، و در نهایت شیوهٔ ارزیابی تجربی این نوع داده با استفاده از کتابخانهٔ استاندارد BenchmarkDotNet می‌پردازد.

using System.Numerics;

// پیاده‌سازی کلاسیک مبتنی بر double
Complex value = new(3.0, 4.0);
Complex result = value * 2.0;

Complex<T>
   ├── Real: T
   └── Imaginary: T

// تعریف نوع با دقت معمولی (۳۲ بیتی)
Complex<float> singlePrecision = new(1.5f, 2.5f);

// تعریف نوع با دقت مضاعف (۶۴ بیتی)
Complex<double> doublePrecision = new(1.5, 2.5);

• نوع دادهٔ float تنها حدود ۷ رقم با‌معنی (Significant Digits) دقت دارد، در حالی که double دقتی در حدود ۱۵ تا ۱۷ رقم ارائه می‌دهد. در الگوریتم‌های تکرارشونده (Iterative) یا فیلترهای پس‌خوراند (IIR Filters)، خطاهای ممیز شناور می‌توانند به‌سرعت تشدید شوند و الگوریتم را از همگرایی خارج کنند.

• محدودهٔ مقادیر قابل بازنمایی در float تقریباً از 10^-45 تا 10^38 است، در حالی که در double این دامنه تا 10^308 گسترش می‌یابد. در محاسبات ماتریسی یا بهینه‌سازی‌های عددی بزرگ، احتمال بروز مقادیر بی‌نهایت (Infinity) یا صفرشدن غیرواقعی مقادیر بسیار کوچک (Denormal/Subnormal Numbers) در float به‌مراتب بیشتر است.

• در یک ثبات ۲۵۶ بیتی (AVX2)، پردازنده می‌تواند ۸ مقدار float (معادل ۴ عدد مختلط تک‌دقت) را در یک پالس ساعت ضرب یا جمع کند.
• برای double، همان ثبات تنها ظرفیت پردازش ۴ مقدار double (معادل ۲ عدد مختلط مضاعف) را داراست.

using System.Numerics;
using BenchmarkDotNet.Attributes;
using BenchmarkDotNet.Running;

[MemoryDiagnoser]
[DisassemblyDiagnoser(printSource: true, maxDepth: 3)] // بررسی خروجی JIT و SIMD
public class ComplexBenchmark
{
    private const int Iterations = 10_000;

    private readonly Complex<float> _floatVal = new(1.0001f, 0.0001f);
    private readonly Complex<double> _doubleVal = new(1.0001, 0.0001);

    [Benchmark(Baseline = true)]
    public Complex<double> DoubleScalarLoop()
    {
        var acc = _doubleVal;
        for (int i = 0; i < Iterations; i++)
        {
            acc *= _doubleVal;
        }
        return acc;
    }

    [Benchmark]
    public Complex<float> FloatScalarLoop()
    {
        var acc = _floatVal;
        for (int i = 0; i < Iterations; i++)
        {
            acc *= _floatVal;
        }
        return acc;
    }
}

[MemoryDiagnoser]
public class ComplexArrayWorkloadBenchmark
{
    private const int Size = 1_000_000;
    private Complex<float>[] _floatArray = null!;
    private Complex<double>[] _doubleArray = null!;

    [GlobalSetup]
    public void Setup()
    {
        _floatArray = new Complex<float>[Size];
        _doubleArray = new Complex<double>[Size];

        for (int i = 0; i < Size; i++)
        {
            _floatArray[i] = new Complex<float>(1.01f, 0.99f);
            _doubleArray[i] = new Complex<double>(1.01, 0.99);
        }
    }

    [Benchmark]
    public void TransformFloatArray()
    {
        var factor = new Complex<float>(0.5f, 0.5f);
        for (int i = 0; i < _floatArray.Length; i++)
        {
            _floatArray[i] *= factor;
        }
    }

    [Benchmark]
    public void TransformDoubleArray()
    {
        var factor = new Complex<double>(0.5, 0.5);
        for (int i = 0; i < _doubleArray.Length; i++)
        {
            _doubleArray[i] *= factor;
        }
    }
}

نکته اجرایی: همواره آزمون‌ها را در حالت انتشار کامپایل کنید:

dotnet run -c Release

public static class NumericalAssertion
{
    public static bool AreApproximatelyEqual(
        Complex<float> actual, 
        Complex<double> expectedReference, 
        float tolerance = 1e-4f)
    {
        float realDiff = MathF.Abs(actual.Real - (float)expectedReference.Real);
        float imagDiff = MathF.Abs(actual.Imaginary - (float)expectedReference.Imaginary);

        return realDiff <= tolerance && imagDiff <= tolerance;
    }
}

• نتیجه‌گیری شتاب‌زده دربارهٔ سرعت بالا: صرفِ نصف بودن بایت‌های float به این معنا نیست که محاسبات پردازنده لزوماً دو برابر سریع‌تر اجرا می‌شود. در مسائل CPU-bound بدون برداری‌سازی کارآمد، واحدهای ممیز شناور (FPU) عملیات تک و مضاعف را معمولاً با Latency مشابهی به پایان می‌رسانند.
• اتکا به بنچ‌مارک‌های اسکالر ساده: حلقه‌های بدون دسترسی به آرایه، رفتار واقعی حافظه کش، TLB Misses و پهنای باند حافظه اصلی را شبیه‌سازی نمی‌کنند.
• تغییر الگوریتم حین آزمون: مقایسه صرفاً زمانی ارزش تحلیلی دارد که هر دو مدل ریاضی دقیقاً همان توالی محاسباتی را طی کنند.
• تعمیم نتایج یک معماری خاص به تمام پلتفرم‌ها: تفاوتی ملموس میان رفتارهای JIT در x64 و ARM64 در مواجهه با کدهای SIMD وجود دارد؛ نتایج نباید بدون آزمایش به دیگر ماشین‌ها تعمیم یابد.

• حجم داده‌ها را ارزیابی کنید: برای آرایه‌های کوچک و متوسط، پیچیدگی تبدیل کدهای موجود به ساختار جنریک ممکن است توجیه عملکردی ملموسی نداشته باشد.
• فشار حافظه را بسنجید: در کاربردهایی با ترافیک پردازشی ده‌ها میلیون عنصر در ثانیه، صرفه‌جویی ۵۰ درصدی حاصل از Complex به‌دلیل کاهش جابجایی داده (Data Movement) می‌تواند بهبودهای جدی ایجاد کند.
• همگام‌سازی با اکوسیستم شخص‌ثالث: مطمئن شوید سایر کتابخانه‌های C/C++ یا کتابخانه‌های محاسباتی بومی (P/Invoke) که داده‌های شما را مصرف می‌کنند، ساختار حافظهٔ ۳۲ بیتی را پشتیبانی می‌کنند.