> ## Content Index
> Fetch the complete content index at: https://arabroot.io/llms.txt
> Use this file to discover other available public pages before exploring further.

# الجذر التربيعي العكسي السريع في Quake III
- URL: https://arabroot.io/articles/الجذر-التربيعي-العكسي-السريع-في-quake-iii-0x5f3759df/
- Published: 2026-11-20T10:26:42.000Z
- Updated: 2026-11-20T11:25:24.000Z
- Description: نفك حيلة 0x5f3759df في Quake III ونرى لماذا تعمل، ثم نقيس خطأها على كل عدد float موجب ونبحث عن أفضل ثابت ونقارن سرعتها بأمر rsqrtss.
- Author: فريق عرب رووت
- Tags: الأدلة التقنية, تطوير الألعاب

إذا قضيت وقتاً في منتديات Forums المبرمجين فغالباً مر عليك هذا السطر، أو على الأقل مر عليك الرقم الذي فيه: `0x5f3759df`. رقم سداسي عشري Hexadecimal لا معنى ظاهراً له، يطرح منه عدد مزاح Shifted بتاً واحداً، فيخرج الجذر التربيعي العكسي Inverse Square Root لأي عدد، أي 1 مقسوماً على جذره، بخطأ أقل من 0.2%، ودون أي قسمة ولا أي جذر. وقد صار هذا السطر من الكود المصدري Source Code للعبة Quake III Arena أشهر سطر في تاريخ برمجة الألعاب، وأكثر سطر قرأه الناس دون أن يفهموه، فمن يقرؤه للمرة الأولى يشعر أن أحداً خدعه.

وفي هذا المقال سوف نفك هذه الخدعة خطوة خطوة: لماذا تحتاج الألعاب هذا الرقم أصلاً، وكيف يخزن الحاسوب العدد العشري، ولماذا تقريب الجذر بإزاحة البتات ليس سحراً وإنما لوغاريتم متنكر، وما دور خطوة نيوتن بعده. ثم لن نكتفي بالشرح، وإنما سوف نكتب الحيلة بأنفسنا بلغة C وPython وJavaScript، ونقيس خطأها Error على كل عدد موجب يمكن أن يخزنه النوع float، أي أكثر من ملياري عدد، ونبحث بأنفسنا عن أفضل رقم سحري، ونقارن سرعتها بالقسمة العادية وبالأمر الذي وضعته Intel في المعالجات لهذا الغرض.

وسوف نناقش في هذا المقال ما يلي:

- لماذا تحسب الألعاب 1 على الجذر ملايين المرات في الثانية: توحيد طول المتجهات Normalization.
- كيف يخزن float في 32 بتاً، ولماذا قراءة بتاته كعدد صحيح تشبه اللوغاريتم.
- من أين جاء الرقم السحري، وما تقوله الرياضيات عنه، وما دور خطوة نيوتن Newton's Method.
- قصة الكود: من Ardent إلى 3dfx إلى id Software، كما كشفها مقالا Beyond3D.
- مختبر: الخطأ على 2,130,706,432 عدداً، والبحث عن أفضل ثابت، والسرعة على معالج اليوم، والخطأ الذي يقع فيه من ينسخ الكود الأصلي على نظام 64 بت.
- لماذا لا تحتاج هذه الحيلة اليوم في أغلب الحالات، وماذا يبقى منها.

وهذا المقال جزء من مرحلة «حيل الألعاب الكلاسيكية»، وفيها نشرح كل حيلة ثم نعيد بناءها بكود يعمل:

[![](https://arabroot.io/content/images/2026/11/light-gun-how-it-works-cover-cover.webp)دليلكيف عرف المسدس الضوئي Light Gun أين أصبت البطة؟نشرح كيف عرف المسدس الضوئي هدفك على شاشة CRT بإطار أسود ومربع أبيض لكل هدف، ونعيد بناء الحيلة في المتصفح ونقيس لماذا تفشل على شاشات اليوم.](https://arabroot.io/articles/%D9%83%D9%8A%D9%81-%D8%B9%D8%B1%D9%81-%D8%A7%D9%84%D9%85%D8%B3%D8%AF%D8%B3-%D8%A7%D9%84%D8%B6%D9%88%D8%A6%D9%8A-light-gun-%D8%A7%D9%8A%D9%86-%D8%A7%D8%B5%D8%A8%D8%AA-%D8%A7%D9%84%D8%A8%D8%B7%D8%A9/)[![](https://arabroot.io/content/images/2026/11/racing-the-beam-cover-cover.webp)دليلAtari 2600: الرسم مع شعاع الشاشة Racing the Beamكيف رسمت ألعاب Atari 2600 صورها دون ذاكرة إطار: نكتب برنامج 6502 صغيراً ونعد دوراته في Stella لنرى ماذا يحدث حين يتأخر الكود عن الشعاع.](https://arabroot.io/articles/atari-2600-%D8%A7%D9%84%D8%B1%D8%B3%D9%85-%D9%85%D8%B9-%D8%B4%D8%B9%D8%A7%D8%B9-%D8%A7%D9%84%D8%B4%D8%A7%D8%B4%D8%A9-racing-the-beam/)[![](https://arabroot.io/content/images/2026/11/pacman-ghost-ai-cover-cover.webp)دليلكيف تفكر أشباح Pac-Man؟ ذكاء بقواعد بسيطةنشرح القواعد الأربع التي تختار بها أشباح Pac-Man أهدافها وجدول موجاتها وخطأ الفيض الشهير، ثم نبنيها على متاهتنا ونقيس أثر كل قاعدة في 392 لعبة.](https://arabroot.io/articles/%D9%83%D9%8A%D9%81-%D8%AA%D9%81%D9%83%D8%B1-%D8%A7%D8%B4%D8%A8%D8%A7%D8%AD-pac-man-%D8%B0%D9%83%D8%A7%D8%A1-%D8%A8%D9%82%D9%88%D8%A7%D8%B9%D8%AF-%D8%A8%D8%B3%D9%8A%D8%B7%D8%A9/)[![](https://arabroot.io/content/images/2026/11/sprite-flicker-limits-cover-cover.webp)دليللماذا كانت الشخصيات ترمش؟ حدود رسوميات NESنشرح لماذا لا يرسم جهاز NES أكثر من ثماني شخصيات في السطر، ونكتب ROM صغيراً يزدحم عمداً ونقيس في FCEUX أي طريقة رمش توزع الاختفاء بعدل.](https://arabroot.io/articles/%D9%84%D9%85%D8%A7%D8%B0%D8%A7-%D9%83%D8%A7%D9%86%D8%AA-%D8%A7%D9%84%D8%B4%D8%AE%D8%B5%D9%8A%D8%A7%D8%AA-%D8%AA%D8%B1%D9%85%D8%B4-%D8%AD%D8%AF%D9%88%D8%AF-%D8%B1%D8%B3%D9%88%D9%85%D9%8A%D8%A7%D8%AA-nes/)[![](https://arabroot.io/content/images/2026/11/doom-bsp-cover-cover.webp)دليلكيف رسمت Doom عالماً ثلاثي الأبعاد بشجرة BSP؟نشرح كيف رتبت Doom جدرانها بشجرة BSP ورسمتها من القريب إلى البعيد، ونبني الشجرة والمرسم بـ Python ونعد ما يفحصه كل أسلوب على خرائط حتى 1,225 جداراً.](https://arabroot.io/articles/%D9%83%D9%8A%D9%81-%D8%B1%D8%B3%D9%85%D8%AA-doom-%D8%B9%D8%A7%D9%84%D9%85%D8%A7-%D8%AB%D9%84%D8%A7%D8%AB%D9%8A-%D8%A7%D9%84%D8%A7%D8%A8%D8%B9%D8%A7%D8%AF-%D8%A8%D8%B4%D8%AC%D8%B1%D8%A9-bsp/)

## لماذا تحتاج اللعبة 1 على الجذر؟

في [مقال رياضيات الألعاب](https://arabroot.io/articles/%D8%B1%D9%8A%D8%A7%D8%B6%D9%8A%D8%A7%D8%AA-%D8%A7%D9%84%D8%A7%D9%84%D8%B9%D8%A7%D8%A8-%D8%A7%D9%84%D9%85%D8%AA%D8%AC%D9%87%D8%A7%D8%AA-vectors-%D9%88%D8%A7%D9%84%D8%AD%D8%B1%D9%83%D8%A9-%D9%88%D8%A7%D9%84%D8%AA%D8%B5%D8%A7%D8%AF%D9%85/) رأينا عملية تتكرر في كل مكان: توحيد طول المتجه Normalize، أي أن تأخذ متجهاً بأي طول وتحوله إلى متجه بطول 1 في الاتجاه نفسه. فالإضاءة تحتاج الاتجاه العمودي Normal لكل سطح بطول 1 لتحسب زاوية الضوء، والحركة تحتاج اتجاه اللاعب بطول 1 لتضربه في السرعة، والانعكاس والتصادم يحتاجانه كذلك. والتوحيد يعني أن تقسم كل مكون من مكونات المتجه على طوله، والطول هو جذر مجموع المربعات، أي أنك تحتاج جذراً تربيعياً ثم قسمة، وفي المتجه الثلاثي الأبعاد ثلاث قسمات. والأرخص أن تحسب 1 على الجذر مرة واحدة، ثم تضرب المكونات الثلاثة فيه، لأن الضرب أسرع بكثير من القسمة.

وفي أواخر التسعينات كان الجذر والقسمة من أبطأ العمليات في المعالج، فكل واحدة منهما تأخذ عشرات الدورات، بينما الضرب والجمع بضع دورات، والأوامر الخاصة التي تحسب 1 على الجذر تقريبياً لم تكن قد وصلت إلى أغلب الأجهزة بعد. ومحرك ثلاثي الأبعاد يحسب الإضاءة والتصادم لآلاف الرؤوس Vertices في كل إطار، فيحتاج هذا الرقم ملايين المرات في الثانية، وكل دورة يوفرها فيه تتضاعف بهذا العدد. ومن هنا جاءت الحاجة إلى طريقة تعطي 1 على الجذر بدقة تكفي للرسم، أي خطأ صغير لا تلاحظه العين في الإضاءة، باستخدام عمليات رخيصة فقط.

### كيف كانت تستخدم في توحيد المتجه؟

والاستخدام نفسه بسيط: تحسب مجموع مربعات المكونات، وهو مربع الطول، ثم تمرره إلى الدالة فتعطيك 1 على الطول مباشرة، ثم تضرب كل مكون فيه. أي أن توحيد متجه ثلاثي الأبعاد يصبح ثلاث عمليات ضرب وجمعين لمربع الطول، ثم الحيلة، ثم ثلاث عمليات ضرب، دون أي جذر أو قسمة. ولاحظ أن الدالة تأخذ مربع الطول لا الطول نفسه، وهذا ما يجعل 1 على الجذر بالذات مفيداً، فلو كانت تعطي الجذر فقط لاحتجت قسمة بعدها. وبدقة 0.175% يخرج المتجه بطول بين 0.998 و1، وهذا لا يغير الإضاءة بشكل يراه اللاعب. ولاحظ أن الخطأ لا يتراكم إذا وحدت المتجه نفسه مرة بعد مرة، لأن كل توحيد يحسب من الطول الحالي، فيبقى الطول دائماً أقصر من 1 بقليل ولا يبتعد أكثر، على عكس جمع الأخطاء الذي شرحناه في مقال الأرقام العشرية.

## كيف يخزن الحاسوب العدد العشري؟

شرحنا تفاصيل هذا في [مقال الأرقام العشرية Floating Point](https://arabroot.io/articles/%D8%A7%D9%84%D8%A3%D8%B1%D9%82%D8%A7%D9%85-%D8%A7%D9%84%D8%B9%D8%B4%D8%B1%D9%8A%D8%A9-floating-point-%D9%85%D9%86-%D8%A7%D9%84%D8%AF%D8%A7%D8%AE%D9%84/)، ونحتاج هنا الفكرة فقط. فالعدد من نوع float بمعيار [IEEE 754](https://en.wikipedia.org/wiki/IEEE%5F754?ref=arabroot.io) يخزن في 32 بتاً، مقسمة إلى ثلاثة أجزاء: بت للإشارة Sign، ثم 8 بتات للأس Exponent، ثم 23 بتاً للكسر Mantissa. والعدد يساوي 1 فاصلة الكسر، مضروباً في 2 مرفوعة إلى الأس ناقص 127\. فالعدد 4 مثلاً هو 1.0 في 2 مرفوعة إلى 2، فأسه المخزن 129، أي 127 زائد 2، وكسره صفر، وبتاته بالسداسي عشري 0x40800000، كما طبعها برنامجنا في المختبر.

والآن الفكرة التي تقوم عليها الحيلة كلها. ماذا يحدث إذا أخذت هذه البتات الـ 32 كما هي، وقرأتها كأنها عدد صحيح Integer؟ الأس في البتات العليا، فكل زيادة فيه بواحد تضيف إلى العدد الصحيح 2 مرفوعة إلى 23، والكسر في البتات الدنيا يضيف قيمة بين 0 و2 مرفوعة إلى 23\. أي أن العدد الصحيح الناتج تقريباً هو 2 مرفوعة إلى 23 مضروبة في (الأس زائد الكسر). والأس هو الجزء الصحيح من لوغاريتم العدد للأساس 2، والكسر تقريب خطي لجزئه الكسري. وبالتالي فإن بتات أي float إذا قرأتها كعدد صحيح، ثم قسمتها على 2 مرفوعة إلى 23 وطرحت 127، تعطيك لوغاريتم العدد للأساس 2 تقريباً. والشكل التالي يرسم الاثنين معاً:

![رسم بياني على محور أفقي من 2 أس سالب 3 إلى 2 أس 5: خط أزرق متصل لـ log2(x) الحقيقي، وخط برتقالي متقطع لبتات العدد كعدد صحيح مقسومة على 2 أس 23 ناقص 127، والخطان متطابقان تقريباً ويلتقيان عند كل قوة للعدد 2](https://arabroot.io/content/images/2026/11/fast-inverse-sqrt-02-log.webp)

بتات float كعدد صحيح هي لوغاريتم العدد تقريباً: الخطان يلتقيان عند كل قوة للعدد 2، وأكبر فرق بينهما 0.086.

والفرق بين الخطين صغير لأن log2 للعدد بين 1 و2 قريب من خط مستقيم، وأكبر فرق بينهما 0.086 عند حوالي 1.44\. وهذا الاكتشاف هو مفتاح كل شيء: إذا كانت البتات لوغاريتماً، فإن العمليات على اللوغاريتم تصبح عمليات على البتات. والجذر التربيعي في عالم اللوغاريتمات قسمة على 2، والمقلوب Reciprocal ضرب في سالب 1، أي أن 1 على الجذر يصبح ضرباً في سالب نصف. والضرب في سالب نصف على عدد صحيح هو إزاحة لليمين بتاً واحداً ثم طرح من شيء ما، وهذا الشيء هو الرقم السحري.

## الرقم السحري: من أين جاء 0x5f3759df؟

لنكتبها بالرموز مرة واحدة. إذا سمينا بتات العدد x كعدد صحيح I(x)، وكتبنا L بدل 2 مرفوعة إلى 23، فإن التقريب السابق هو I(x) يساوي تقريباً L في (log2 x زائد 127 ناقص σ)، حيث σ تصحيح صغير يقلل الخطأ في المتوسط بدل أن يكون صفراً عند قوى العدد 2\. ونريد y يساوي 1 على جذر x، أي log2 y يساوي سالب نصف log2 x. وإذا عوضنا في التقريب نجد:

I(y) ≈ (3/2) × L × (127 − σ) − I(x) / 2

والجزء الأول ثابت لا يعتمد على x، وهو الرقم السحري. ومع σ تساوي حوالي 0.04505 يصبح الثابت 1.5 في 2 مرفوعة إلى 23 في 126.95495، أي 1,597,463,007 بالعشري، وهو بالضبط 0x5f3759df، وهذا ما حسبناه بسطر Python في المختبر. أما الجزء الثاني فهو العدد الصحيح مزاحاً لليمين بتاً واحداً، وهذا هو `i >> 1` في الكود. والشكل التالي يتتبع الخطوات على بتات العدد 4:

![أربعة صفوف من 32 خانة ملونة: بت الإشارة بالأحمر و8 بتات الأس بالأزرق و23 بت الكسر بالأخضر. الصف الأول x = 4 بالقيمة 0x40800000، والثاني بعد الإزاحة 0x20400000، والثالث الرقم السحري 0x5f3759df، والرابع الفرق 0x3ef759df أي التخمين 0.483107537، وتحتها خطوة نيوتن تعطي 0.499153584](https://arabroot.io/content/images/2026/11/fast-inverse-sqrt-01-bits.webp)

الرقم 4 خلال الحيلة: الإزاحة تقسم الأس على 2، والطرح من الرقم السحري يقلب الإشارة ويعيد الأس إلى مكانه، فيخرج 0.4831 بدل 0.5.

ولاحظ في الشكل ما تفعله الإزاحة بالأس: الأس 129 صار في البتات 64 والنصف، أي أن الأس قسم على 2 تقريباً، والبت الأدنى منه انتقل إلى أعلى الكسر، وهذا ليس خطأ وإنما جزء من الحيلة، لأن الأس الفردي حين يقسم على 2 يترك نصفاً يجب أن يذهب إلى الكسر. ثم الطرح من الرقم السحري يقلب الإشارة في عالم اللوغاريتم، ويضيف 127 مرة ونصف التي ضاعت حين أزحنا. والنتيجة 0x3ef759df، أي 0.483107537 بدل 0.5، بخطأ 3.4%. وهذا تخمين أولي جيد جداً لعمليتين على عدد صحيح، ولكنه ليس دقيقاً بما يكفي للإضاءة، وهنا يأتي الجزء الثاني.

## خطوة نيوتن: من 3.4% إلى 0.17%

طريقة نيوتن Newton's Method أداة قديمة لتحسين حل تقريبي لمعادلة: تبدأ بتخمين، وتنظر إلى ميل الدالة عنده، وتنزلق على هذا الميل إلى حيث يقطع المحور، فتحصل على تخمين أفضل، كما تشرح [صفحة الطريقة في Wikipedia](https://en.wikipedia.org/wiki/Newton%27s%5Fmethod?ref=arabroot.io). ونحن نبحث عن y الذي يجعل 1 على y مربعاً يساوي x، أي الجذر للدالة f(y) يساوي 1 على y تربيع ناقص x. وإذا طبقت قاعدة نيوتن على هذه الدالة بالذات خرجت معادلة جميلة لا قسمة فيها:

yجديد \= y × (1.5 − 0.5 × x × y × y)

ثلاث عمليات ضرب وطرح واحد، وهذا سبب اختيار هذه الدالة بالذات وليس f(y) يساوي y تربيع ناقص 1 على x، لأن الثانية كانت ستحتاج قسمة. وطريقة نيوتن تضاعف عدد الأرقام الصحيحة تقريباً في كل خطوة حين تكون قريباً من الحل، ولذلك فإن خطوة واحدة نقلت العدد 4 من 0.4831 إلى 0.49915، أي من خطأ 3.4% إلى 0.17%، وخطوة ثانية تنزل بالخطأ إلى أجزاء من المليون كما سوف نقيس. وفي الكود الأصلي كانت الخطوة الثانية مكتوبة ولكن معطلة بتعليق، لأن 0.17% كانت كافية للعبة.

### لماذا تحسن خطوة واحدة الدقة عشرين مرة؟

يمكن أن نرى هذا بحساب صغير دون أي برنامج. لنسم خطأ التخمين e، بحيث يكون x في y تربيع يساوي 1 زائد e، فإذا كان y صحيحاً تماماً كانت e صفراً. والخطوة تضرب y في 1.5 ناقص نصف (1 زائد e)، أي في 1 ناقص e على 2\. وإذا حسبت x في y الجديد تربيع وجدت 1 ناقص ثلاثة أرباع e تربيع، زائد ربع e تكعيب. أي أن الخطأ الجديد يتناسب مع مربع الخطأ القديم، وهذا ما يسمى التقارب التربيعي Quadratic Convergence. والتخمين في أسوأ حالاته يخطئ في y بـ 3.44%، فتكون e حوالي ضعف ذلك، أي 0.069، وثلاثة أرباع مربعها 0.0036، والخطأ في y نصف ذلك تقريباً، أي 0.18%، وهو قريب جداً من 0.1752% التي سوف نقيسها على كل الأعداد. ولاحظ أيضاً الإشارة: الحد الرئيسي سالب دائماً مهما كانت إشارة e، فالناتج بعد الخطوة أقل من الصحيح دائماً، سواء كان التخمين أكبر منه أو أصغر، وهذا ما سوف يظهر في الرسم بعد قليل.

## الكود في Quake III

صدرت Quake III Arena في ديسمبر 1999 كما تذكر [صفحة اللعبة في Wikipedia](https://en.wikipedia.org/wiki/Quake%5FIII%5FArena?ref=arabroot.io)، ونشرت id Software كودها المصدري تحت رخصة GPL في أغسطس 2005، وهو اليوم على [GitHub في ملف q\_math.c](https://github.com/id-Software/Quake-III-Arena/blob/master/code/game/q%5Fmath.c?ref=arabroot.io) في الدالة Q\_rsqrt. والدالة قصيرة جداً، والسطر المشهور فيها هو:

```c
i  = 0x5f3759df - ( i >> 1 );
```

وقبله سطر يقرأ بتات العدد العشري كعدد صحيح بتحويل المؤشر Pointer Cast، أي أخذ عنوان المتغير العشري ومعاملته كعنوان عدد صحيح، وبعده سطر يعيد البتات إلى عدد عشري بالطريقة نفسها، ثم خطوة نيوتن، ثم خطوة ثانية معطلة. وعلى السطرين تعليقان صارا جزءاً من ثقافة المبرمجين، أحدهما يصف ما يحدث بأنه عبث على مستوى البتات، والآخر تعبير عن الدهشة لا يصلح لنقله هنا. ولن ننسخ الدالة، وإنما سوف نكتب نسختنا في المختبر بالطريقة الصحيحة في C الحديثة، ونرى لماذا الطريقة الأصلية في قراءة البتات خطيرة اليوم.

## من كتب هذا السطر؟

حين نشر الكود سأل الجميع: من صاحب هذه الفكرة؟ وكان الظن الأول أنه John Carmack. ونشر Rys Sommefeldt في موقع Beyond3D [مقالاً أول](https://www.beyond3d.com/content/articles/8/?ref=arabroot.io) يتتبع الأصل، فراسل John Carmack عام 2004، فرد بأنه ليس هو ورجح Terje Mathisen، ثم راسل Mathisen عام 2005 فقال إنه كتب دالة مشابهة لمحاكاة كيميائية ولكن هذا الكود ليس له، ثم وصل إلى Gary Tarolli الذي عمل في SGI ثم في 3dfx، فقال إنه يعرف الكود جيداً ولكنه لا يستطيع أن ينسبه لنفسه، وإنه رآه قبل أكثر من عشر سنوات وربما عدل الثابت. وبعد أن انتشر المقال تواصل مع الموقع الكاتب الحقيقي، فنشر Rys في ديسمبر 2006 [مقالاً ثانياً](https://www.beyond3d.com/content/articles/15/?ref=arabroot.io): الكاتب Greg Walsh، أحد مؤسسي شركة Ardent Computer التي صنعت حواسيب رسوم متوازية، وكتبها لحاسوب الشركة Titan حين كان البرنامج الذي لا يستطيع استخدام وحدات المتجهات فيه بطيئاً، وكانت الفكرة الأولى بتأثير من Cleve Moler، الذي أسس لاحقاً شركة MathWorks صاحبة MATLAB، وكان يدرس حينها طريقة نيوتن للتقريب. ثم انتقلت الدالة عبر Tarolli إلى 3dfx، ومنها إلى id Software مع Brian Hook كما يقول المقال.

والفكرة نفسها أقدم من Ardent، فتذكر [صفحة الحيلة في Wikipedia](https://en.wikipedia.org/wiki/Fast%5Finverse%5Fsquare%5Froot?ref=arabroot.io) أن William Kahan وK.C. Ng كتبا في مايو 1986 ورقة غير منشورة تصف حساب الجذر بالتلاعب بالبتات ثم خطوات نيوتن. أي أن السطر الذي اشتهر باسم Quake كان في الحقيقة نتاج سلسلة من المهندسين، كل واحد أخذه من الذي قبله، وهذا شائع جداً في الحيل الهندسية الجيدة.

📌

في 2003 نشر Chris Lomont ورقة بعنوان [Fast Inverse Square Root](https://www.lomont.org/papers/2003/InvSqrt.pdf?ref=arabroot.io) حاول فيها أن يشتق الرقم السحري رياضياً، فوجد أن أفضل ثابت للتخمين وحده هو 0x5f37642f، ولكنه بعد خطوة نيوتن أسوأ قليلاً من الأصلي، وأن 0x5f375a86 أفضل من الأصلي في كل مرحلة. وسوف نعيد هذا البحث بأنفسنا في المختبر ونرى إلى أي حد كان الرقم الأصلي قريباً من الأفضل.

## المختبر: نقيس الحيلة على كل عدد ممكن

الآن سوف نكتب الحيلة بأنفسنا ونقيسها. والمختبر ثلاثة ملفات: rsqrt.c وفيه كل القياسات الثقيلة بلغة C، وrsqrt.py وrsqrt.mjs يكتبان الحيلة نفسها بـ Python وJavaScript ليتأكد أن البتات تخرج متطابقة في اللغات الثلاث. وشغلنا C داخل Container مؤقت من alpine:3.22 يثبت المترجم gcc عند كل تشغيل ثم يحذف معه، فلا تبقى أي Image جديدة على الجهاز، على معالج Intel Core i7-7700K:

```bash
#!/bin/sh
# Installs gcc in a throw-away alpine container, builds and runs every part of the lab.
set -e
apk add -q gcc musl-dev
gcc --version | head -1
grep -m1 "model name" /proc/cpuinfo
gcc -O2 -fno-tree-vectorize -msse2 -Wall rsqrt.c -o rsqrt -lm
./rsqrt show 4 2 0.15625 100 > out-01-show.txt
./rsqrt speed > out-03-speed.txt
./rsqrt error > out-02-error.txt
./rsqrt search > out-04-search.txt
echo "--- -O2 -Wall on longbug.c" > out-05-longbug.txt
gcc -O2 -Wall longbug.c -o longbug >> out-05-longbug.txt 2>&1
./longbug >> out-05-longbug.txt
echo "--- -O0" >> out-05-longbug.txt
gcc -O0 longbug.c -o longbug0 && ./longbug0 >> out-05-longbug.txt
```

```bash
docker run --rm -v "$PWD/lab:/lab" -w /lab alpine:3.22 sh build-run.sh
```

```text
gcc (Alpine 14.2.0) 14.2.0
model name	: Intel(R) Core(TM) i7-7700K CPU @ 4.20GHz
```

### الكود: rsqrt.c

```c
/* rsqrt.c: the fast inverse square root trick, measured.
 * Written for the ArabRoot article; our own code, following the algorithm in Quake III Arena's q_math.c (GPL).
 *   ./rsqrt error      max and mean relative error over every positive normal float
 *   ./rsqrt search     the best magic constant, with and without the Newton step
 *   ./rsqrt speed      nanoseconds per value: 1/sqrtf, the trick, rsqrtss, rsqrtss + Newton
 *   ./rsqrt show X     the steps for one number
 * Build: gcc -O2 -fno-tree-vectorize -msse2 rsqrt.c -o rsqrt -lm
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <math.h>
#include <time.h>
#include <xmmintrin.h>

static inline uint32_t bits_of(float f) { uint32_t i; memcpy(&i, &f, 4); return i; }
static inline float float_of(uint32_t i) { float f; memcpy(&f, &i, 4); return f; }

/* the guess alone: shift the bits right by one and subtract from the magic number */
static inline float guess(float x, uint32_t magic) { return float_of(magic - (bits_of(x) >> 1)); }

/* the guess plus one Newton step, as in the game */
static inline float rsqrt_newton(float x, uint32_t magic) {
    float y = guess(x, magic);
    return y * (1.5f - 0.5f * x * y * y);
}
static inline float rsqrt_newton2(float x, uint32_t magic) {
    float y = rsqrt_newton(x, magic);
    return y * (1.5f - 0.5f * x * y * y);
}
/* Jan Kadlec's version: a different magic number and different Newton constants */
static inline float rsqrt_kadlec(float x) {
    float y = float_of(0x5F1FFFF9u - (bits_of(x) >> 1));
    return y * 0.703952253f * (2.38924456f - x * y * y);
}
/* the hardware instruction (about 12 bits) and the same instruction plus one Newton step */
static inline float rsqrt_sse(float x) { return _mm_cvtss_f32(_mm_rsqrt_ss(_mm_set_ss(x))); }
static inline float rsqrt_sse_newton(float x) { float y = rsqrt_sse(x); return y * (1.5f - 0.5f * x * y * y); }

enum { GUESS, NEWTON, NEWTON2, KADLEC, SSE, SSE_NEWTON, NKIND };
static const char *NAMES[NKIND] = {"guess only (0x5f3759df)", "guess + 1 Newton (Quake)", "guess + 2 Newton",
                                   "Kadlec 0x5F1FFFF9", "rsqrtss", "rsqrtss + 1 Newton"};
static inline float approx(int kind, float x, uint32_t magic) {
    switch (kind) {
    case GUESS: return guess(x, magic);
    case NEWTON: return rsqrt_newton(x, magic);
    case NEWTON2: return rsqrt_newton2(x, magic);
    case KADLEC: return rsqrt_kadlec(x);
    case SSE: return rsqrt_sse(x);
    default: return rsqrt_sse_newton(x);
    }
}

/* relative error against the exact value computed in double */
static inline double rel_err(float y, float x) { double e = 1.0 / sqrt((double)x); return fabs((double)y - e) / e; }

/* max relative error over the floats with bits lo..hi-1, every "stride"-th one */
static double max_err(int kind, uint32_t magic, uint32_t lo, uint32_t hi, uint32_t stride, uint32_t *where, double *mean) {
    double m = 0, sum = 0; uint64_t n = 0;
    for (uint32_t b = lo; b < hi; b += stride) {
        float x = float_of(b); double e = rel_err(approx(kind, x, magic), x);
        sum += e; n++;
        if (e > m) { m = e; if (where) *where = b; }
    }
    if (mean) *mean = sum / n;
    return m;
}

static void cmd_error(void) {
    const uint32_t lo = 0x00800000u, hi = 0x7F800000u;  /* all positive normal floats: 2,130,706,432 values */
    printf("all positive normal floats: %u values\n", hi - lo);
    for (int k = 0; k < NKIND; k++) {
        uint32_t where = 0; double mean;
        clock_t t = clock();
        double m = max_err(k, 0x5f3759dfu, lo, hi, 1, &where, &mean);
        printf("%-26s max %.8f (%.4f%%) at x = %-13.7g mean %.8f  [%.1f s]\n", NAMES[k], m, m * 100, float_of(where), mean,
               (double)(clock() - t) / CLOCKS_PER_SEC);
    }
}

/* the error repeats every two octaves, so [1, 4) is enough to rank constants */
static void cmd_search(void) {
    const uint32_t lo = 0x3F800000u, hi = 0x40800000u;  /* [1.0, 4.0): 16,777,216 floats */
    for (int kind = GUESS; kind <= NEWTON; kind++) {
        uint32_t best = 0; double best_e = 1e9;
        for (uint32_t m = 0x5f370000u; m < 0x5f380000u; m += 16) {             /* coarse: every 16th constant, 1/64 of the floats */
            double e = max_err(kind, m, lo, hi, 64, NULL, NULL);
            if (e < best_e) { best_e = e; best = m; }
        }
        uint32_t c0 = best - 32;
        best_e = 1e9;
        for (uint32_t m = c0; m <= c0 + 64; m++) {                            /* fine: every constant near it, every float */
            double e = max_err(kind, m, lo, hi, 1, NULL, NULL);
            if (e < best_e) { best_e = e; best = m; }
        }
        printf("%-26s best magic 0x%08x  max %.8f\n", kind == GUESS ? "guess only" : "guess + 1 Newton", best, best_e);
        uint32_t list[] = {0x5f3759dfu, 0x5f375a86u, 0x5f37642fu, best};
        for (int i = 0; i < 4; i++)
            printf("    0x%08x  max %.8f\n", list[i], max_err(kind, list[i], lo, hi, 1, NULL, NULL));
    }
    printf("%-26s max %.8f\n", NAMES[KADLEC], max_err(KADLEC, 0, lo, hi, 1, NULL, NULL));
}

static double now(void) { struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts); return ts.tv_sec + ts.tv_nsec * 1e-9; }

static void cmd_speed(void) {
    enum { N = 1 << 20, REP = 50 };
    float *in = malloc(N * sizeof(float)), *out = malloc(N * sizeof(float));
    srand(1);
    for (int i = 0; i < N; i++) in[i] = 0.001f + (float)rand() / RAND_MAX * 1000.0f;
    const char *names[] = {"1.0f / sqrtf(x)", "guess + 1 Newton (Quake)", "rsqrtss", "rsqrtss + 1 Newton"};
    for (int k = 0; k < 4; k++) {
        double best = 1e9; volatile float sink = 0;
        for (int r = 0; r < 5; r++) {
            double t = now();
            for (int rep = 0; rep < REP; rep++)
                for (int i = 0; i < N; i++) {
                    float x = in[i];
                    out[i] = k == 0 ? 1.0f / sqrtf(x) : k == 1 ? rsqrt_newton(x, 0x5f3759dfu) : k == 2 ? rsqrt_sse(x) : rsqrt_sse_newton(x);
                }
            t = now() - t; sink += out[N / 2];
            if (t < best) best = t;
        }
        printf("%-26s %.3f ns per value\n", names[k], best * 1e9 / ((double)N * REP));
    }
}

static void cmd_show(float x) {
    uint32_t b = bits_of(x), h = b >> 1, g = 0x5f3759dfu - h;
    printf("x            = %.9g   bits 0x%08x  sign %u  exponent %u (2^%d)  mantissa 0x%06x\n", x, b, b >> 31, (b >> 23) & 0xFF,
           (int)((b >> 23) & 0xFF) - 127, b & 0x7FFFFF);
    printf("bits >> 1    = 0x%08x\n", h);
    printf("0x5f3759df - = 0x%08x  -> guess %.9g\n", g, float_of(g));
    printf("after Newton = %.9g\n", rsqrt_newton(x, 0x5f3759dfu));
    printf("exact        = %.9g\n", 1.0 / sqrt((double)x));
    printf("rsqrtss      = %.9g\n", rsqrt_sse(x));
}

int main(int argc, char **argv) {
    const char *c = argc > 1 ? argv[1] : "error";
    if (!strcmp(c, "error")) cmd_error();
    else if (!strcmp(c, "search")) cmd_search();
    else if (!strcmp(c, "speed")) cmd_speed();
    else if (!strcmp(c, "show")) for (int i = 2; i < argc; i++) cmd_show(strtof(argv[i], NULL));
    return 0;
}
```

في الكود أعلاه لاحظ التالي:

- **bits\_of وfloat\_of:** تنقلان البتات بين float وuint32\_t بالدالة memcpy بدل تحويل المؤشر، وهذه هي الطريقة الصحيحة في C لأن قواعد اللغة لا تسمح بقراءة متغير من نوع عبر مؤشر من نوع آخر، وهذا ما يسمى قاعدة Strict Aliasing. والمترجم يحول memcpy من 4 بايتات إلى أمر نقل واحد، فلا يوجد أي ثمن.
- **guess وrsqrt\_newton وrsqrt\_newton2:** التخمين وحده، ثم مع خطوة نيوتن كما في اللعبة، ثم مع خطوتين.
- **rsqrt\_kadlec:** نسخة Jan Kadlec التي غيرت الرقم السحري إلى 0x5F1FFFF9 وغيرت أيضاً ثابتي خطوة نيوتن، فصار شكلها y في 0.703952253 في (2.38924456 ناقص x في y في y). والفكرة أن خطوة نيوتن نفسها لم تعد مقدسة، فإذا كنت ستأخذ خطوة واحدة فقط فاختر ثوابتها لتقلل أكبر خطأ بعدها لا قبلها.
- **rsqrt\_sse:** الأمر rsqrtss الذي أضافته Intel في مجموعة SSE مع معالج Pentium III عام 1999، كما تذكر [صفحة SSE في Wikipedia](https://en.wikipedia.org/wiki/Streaming%5FSIMD%5FExtensions?ref=arabroot.io)، وتوثق صفحة [الأمر RSQRTSS](https://www.felixcloutier.com/x86/rsqrtss?ref=arabroot.io) أن خطأه النسبي لا يتجاوز 1.5 في 2 مرفوعة إلى سالب 12، أي حوالي 0.037%. ونستدعيه بالدالة \_mm\_rsqrt\_ss من ملف الترويسة xmmintrin.h.
- **rel\_err:** يحسب الخطأ النسبي مقابل القيمة الدقيقة المحسوبة بـ double، أي بدقة أعلى بكثير من float.
- **cmd\_error:** يمر على كل الأعداد الموجبة العادية Normal في float، من البتات 0x00800000 إلى 0x7F7FFFFF، ويحسب لكل واحد منها الخطأ، لكل نسخة من النسخ الست.
- **cmd\_search:** يبحث عن أفضل رقم سحري على المدى من 1 إلى 4 فقط، والسبب أن خطأ الحيلة يتكرر كل أسين، أي كل ضرب في 4، فالمدى من 1 إلى 4 يمثل كل الأعداد. يبحث أولاً كل 16 ثابتاً على عينة، ثم يفحص كل ثابت حول الأفضل على كل الأعداد في المدى، 16,777,216 عدداً لكل ثابت.
- **cmd\_speed:** يحسب النسخ على مليون عدد عشوائي خمسين مرة، ويأخذ أفضل زمن من خمسة تشغيلات. والخيار `-fno-tree-vectorize` في التجميع يمنع المترجم من تحويل الحلقة إلى أوامر متجهات SIMD، حتى نقيس العدد الواحد كما كانت اللعبة تحسبه.

## التجربة الأولى: الحيلة خطوة خطوة

```bash
./rsqrt show 4 2 0.15625 100
```

```text
x            = 4   bits 0x40800000  sign 0  exponent 129 (2^2)  mantissa 0x000000
bits >> 1    = 0x20400000
0x5f3759df - = 0x3ef759df  -> guess 0.483107537
after Newton = 0.499153584
exact        = 0.5
rsqrtss      = 0.49987793
x            = 2   bits 0x40000000  sign 0  exponent 128 (2^1)  mantissa 0x000000
bits >> 1    = 0x20000000
0x5f3759df - = 0x3f3759df  -> guess 0.716215074
after Newton = 0.706930041
exact        = 0.707106781
rsqrtss      = 0.70690918
x            = 0.15625   bits 0x3e200000  sign 0  exponent 124 (2^-3)  mantissa 0x200000
bits >> 1    = 0x1f100000
0x5f3759df - = 0x402759df  -> guess 2.6148603
after Newton = 2.52548623
exact        = 2.52982213
rsqrtss      = 2.52929688
x            = 100   bits 0x42c80000  sign 0  exponent 133 (2^6)  mantissa 0x480000
bits >> 1    = 0x21640000
0x5f3759df - = 0x3dd359df  -> guess 0.103198759
after Newton = 0.0998448804
exact        = 0.1
rsqrtss      = 0.0999908447
```

في المخرج أعلاه لاحظ التالي:

- العدد 4 بتاته 0x40800000، والأس 129 أي 2 مرفوعة إلى 2، والكسر صفر، كما شرحنا. وبعد الإزاحة 0x20400000، وبعد الطرح 0x3ef759df، والتخمين 0.4831، وبعد نيوتن 0.49915.
- العدد 0.15625 هو المثال الذي تستخدمه صفحة Wikipedia، وأعطى برنامجنا التخمين 2.6149 وبعد نيوتن 2.5255، والقيمة الدقيقة 2.5298، أي خطأ 3.4% ثم 0.17%، وهي النسب نفسها التي تذكرها الصفحة.
- rsqrtss أدق من الحيلة مع خطوة نيوتن في الأعداد الأربعة: 0.49988 للعدد 4 مقابل 0.49915، أي أن الأمر الذي في العتاد وحده يعطي دقة أعلى من الحيلة كلها.
- التخمين وحده قد يكون أكبر من القيمة الدقيقة أو أصغر منها، فالعدد 2 أعطى 0.7162 مقابل 0.7071، أما بعد خطوة نيوتن فالناتج أقل من الدقيق في الأمثلة الأربعة، وهذا ليس صدفة كما سوف نرى في الرسم.

## التجربة الثانية: الخطأ على 2,130,706,432 عدداً

أربعة أمثلة لا تكفي، والسؤال الحقيقي هو: ما أكبر خطأ يمكن أن تعطيه الحيلة لأي عدد؟ والجميل في float أن عدد قيمه الموجبة العادية محدود، أكثر من ملياري قيمة بقليل، وC يمر عليها كلها في ثوان:

```bash
./rsqrt error
```

```text
all positive normal floats: 2130706432 values
guess only (0x5f3759df)    max 0.03437577 (3.4376%) at x = 4.384265e-38  mean 0.02327413  [14.7 s]
guess + 1 Newton (Quake)   max 0.00175234 (0.1752%) at x = 4.384266e-38  mean 0.00095436  [26.8 s]
guess + 2 Newton           max 0.00000473 (0.0005%) at x = 4.385656e-38  mean 0.00000188  [35.8 s]
Kadlec 0x5F1FFFF9          max 0.00065020 (0.0650%) at x = 3.526484e-38  mean 0.00039489  [33.0 s]
rsqrtss                    max 0.00032613 (0.0326%) at x = 2.390019e-38  mean 0.00009359  [28.2 s]
rsqrtss + 1 Newton         max 0.00000030 (0.0000%) at x = 1.188134e-38  mean 0.00000004  [35.0 s]
```

في المخرج أعلاه لاحظ التالي:

- التخمين وحده أكبر خطأ له 3.44%، ومتوسطه 2.33%، أي أنه سيئ بشكل منتظم تقريباً، وليس جيداً في أغلب الأعداد وسيئاً في القليل منها.
- خطوة نيوتن واحدة كما في Quake أنزلت أكبر خطأ إلى 0.1752%، أي حوالي 1 من 570، والمتوسط 0.095%. وهذا يعني أن متجهاً موحداً بهذه الحيلة يكون طوله بين 0.998 و1، وهذا لا يرى في الإضاءة.
- خطوتا نيوتن تنزلان الخطأ إلى 0.0005%، أي أن الخطوة الثانية حسنت الدقة 370 مرة، وهذا هو التضاعف السريع الذي تعد به طريقة نيوتن.
- ثوابت Kadlec أعطت 0.065%، أي أدق من الأصلية بمرتين وسبعة أعشار، بالعدد نفسه من العمليات، فقط بثوابت مختلفة.
- rsqrtss وحده 0.0326%، وهو داخل الحد الذي توثقه Intel، ومع خطوة نيوتن واحدة ينزل إلى 0.00003%، أي قرابة دقة float الكاملة.
- أكبر خطأ في كل الحالات وقع عند أعداد صغيرة جداً قرب 10 أس سالب 38، ولكن هذا لا يعني أن الأعداد الصغيرة أسوأ، فالخطأ يتكرر بالشكل نفسه في كل أسين، وأول مكان يصل فيه البحث إلى القيمة العظمى هو الذي يطبع.

والشكل التالي يبين كيف يتغير الخطأ بين 1 و4، أي دورة كاملة من التكرار:

![ثلاثة رسوم للخطأ النسبي بين x = 1 وx = 4: الأول للتخمين وحده بالأحمر بين صفر و3.4% فوق خط الصفر دائماً تقريباً، والثاني بعد خطوة نيوتن بالبرتقالي بين صفر و0.18% وفوق الصفر دائماً، والثالث لثوابت Kadlec بالأزرق موزع فوق الصفر وتحته وأصغر](https://arabroot.io/content/images/2026/11/fast-inverse-sqrt-03-error.webp)

الخطأ بين 1 و4: خطوة نيوتن الأصلية تبقي الناتج أقل من الصحيح دائماً، أما ثوابت Kadlec فتوزع الخطأ على الجهتين فيصغر أكبره.

ولاحظ في الرسم شيئاً لا تظهره الأرقام: خطوة نيوتن الأصلية تعطي ناتجاً أقل من الصحيح في كل نقطة تقريباً، فالمنحنى البرتقالي فوق الصفر دائماً بالطريقة التي حسبنا بها الخطأ. وهذه خاصية معروفة لهذه الصيغة من نيوتن، فهي تقترب من الحل من جهة واحدة. وهذا بالضبط ما استغلته ثوابت Kadlec: بدل أن يكون الخطأ كله في جهة واحدة من صفر إلى 0.175%، تضرب الناتج في ثابت يرفعه قليلاً فيصبح الخطأ موزعاً بين سالب وموجب، فيصغر أكبره. والفكرة أعم من هذه الحيلة: حين تقرب شيئاً ويكون خطؤك كله في اتجاه واحد، فهناك غالباً تصحيح بسيط يقسم الخطأ إلى نصفين.

## التجربة الثالثة: هل كان 0x5f3759df أفضل رقم؟

```bash
./rsqrt search
```

```text
guess only                 best magic 0x5f37642f  max 0.03421284
    0x5f3759df  max 0.03437577
    0x5f375a86  max 0.03436546
    0x5f37642f  max 0.03421284
    0x5f37642f  max 0.03421284
guess + 1 Newton           best magic 0x5f375a87  max 0.00175129
    0x5f3759df  max 0.00175234
    0x5f375a86  max 0.00175130
    0x5f37642f  max 0.00177589
    0x5f375a87  max 0.00175129
Kadlec 0x5F1FFFF9          max 0.00065020
```

في المخرج أعلاه لاحظ التالي:

- **للتخمين وحده** وجد البحث أفضل ثابت 0x5f37642f، وهو بالضبط الثابت الذي وجده Lomont عام 2003، وأكبر خطأ له 3.421% مقابل 3.438% للأصلي.
- **بعد خطوة نيوتن** وجد البحث 0x5f375a87 بخطأ 0.175129%، والثابت الذي نشره Lomont 0x5f375a86 أعطى 0.175130%، أي أن الفرق بينهما في الرقم السابع بعد الفاصلة، وهو أقل من دقة التقريب في float نفسه، فالاثنان عملياً الثابت نفسه.
- والثابت 0x5f37642f، الأفضل للتخمين، يصبح أسوأ من الأصلي بعد نيوتن: 0.1776% مقابل 0.1752%، وهذا ما وجده Lomont أيضاً، والسبب أن نيوتن يعالج أنواع الخطأ بشكل مختلف، فالتخمين الأفضل ليس بالضرورة البداية الأفضل.
- والأهم: الأصلي 0x5f3759df أسوأ من الأفضل بـ 0.000001 فقط بعد نيوتن، أي واحد من مليون. فمن اختار هذا الرقم، أياً كانت طريقته، كان قريباً جداً من الأفضل، وهذا يرجح أنه بحث عنه بالتجربة بعد خطوة نيوتن لا قبلها.

وقد يتساءل البعض: هل يكفي البحث بين 1 و4 ليحكم على الثابت لكل الأعداد؟ والإجابة نعم، والسبب في الأس. فإذا ضربت x في 4 زاد أسه 2، والإزاحة تحول هذه الزيادة إلى نقص 1 بالضبط في أس الناتج، أي أن الناتج يقسم على 2 تماماً كما يجب لـ 1 على الجذر، وكسر الناتج لا يتغير، فالخطأ النسبي نفسه. أما إذا ضربت x في 2 فقط فإن الزيادة 1 في الأس تصبح نصفاً، والنصف ينتقل إلى أعلى بت في الكسر، فيتغير شكل التقريب. ولذلك يتكرر الخطأ كل أسين لا كل أس، والمدى من 1 إلى 4 فيه أسان كاملان، أي كل الحالات الممكنة. وهذا ما أكده القياس الشامل: أكبر خطأ على ملياري عدد، 0.175234%، هو نفسه أكبر خطأ على المدى من 1 إلى 4 في البحث.

![منحنى أزرق لأكبر خطأ بعد خطوة نيوتن على محور الثوابت من 0x5f374000 إلى 0x5f377400، ينزل إلى قاع قرب 0.175% ثم يصعد، وعليه ثلاث نقاط: برتقالية للثابت الأصلي 0x5f3759df، وخضراء ملاصقة لها للثابت 0x5f375a87 من بحثنا، وبنفسجية أعلى للثابت 0x5f37642f](https://arabroot.io/content/images/2026/11/fast-inverse-sqrt-05-search.webp)

أكبر خطأ بعد نيوتن لكل ثابت: الأصلي ملاصق تقريباً لقاع المنحنى.

## ماذا لو أعطيتها صفراً أو عدداً سالباً؟

الحيلة كتبت لأعداد موجبة عادية، ولا تتحقق من أي شيء، فماذا تعطي إذا وصل إليها ما لا تتوقعه؟ وكتبنا edge.py ليجرب ذلك بنسخة Python نفسها، مع تحويل أي ناتج أكبر من مدى float إلى لانهاية كما يفعل C:

```text
# Windows 11 host, Python 3.13.3
x = 0      bits 0x00000000  trick 1.98178e+19  exact inf
x = 1e-40  bits 0x000116c2  trick 1.96446e+19  exact 1e+20
x = 1e-38  bits 0x006ce3ee  trick 9.9259e+18  exact 1e+19
x = -4     bits 0xc0800000  trick -inf  exact nan
x = inf    bits 0x7f800000  trick -inf  exact 0
x = nan    bits 0x7fc00000  trick nan  exact nan
```

في المخرج أعلاه لاحظ التالي:

- **الصفر:** بتاته كلها أصفار، فالطرح يعطي الرقم السحري نفسه، والناتج 1.98 في 10 أس 19 بدل اللانهاية. أي أن متجهاً طوله صفر سوف يضرب في عدد ضخم ولكنه محدود، والنتيجة متجه صفري بدل NaN، وقد يبدو هذا مريحاً لكنه يخفي الخطأ بدل أن يظهره.
- **الأعداد دون العادية Subnormal:** مثل 10 أس سالب 40، وهي أصغر من أصغر عدد عادي، ولا يتبع تمثيلها قاعدة الأس نفسها، فأعطت الحيلة 1.96 في 10 أس 19 بدل 10 أس 20، أي خطأ 80%. ولذلك استبعدنا هذه الأعداد من قياس الخطأ الشامل، فهو يبدأ من أصغر عدد عادي.
- **السالب واللانهاية:** أعطيا سالب لانهاية، أي جواباً بلا معنى في الحالتين بدل NaN في الأولى وصفر في الثانية. أما NaN فبقي NaN.

والدرس أن الحيلة دالة لمدى محدد، وكل ما خارجه مسؤوليتك أنت قبل أن تستدعيها.

## التجربة الرابعة: هل ما زالت أسرع؟

هنا السؤال الذي يهم أي مبرمج اليوم: هل أستخدم هذه الحيلة في كودي؟

```bash
./rsqrt speed
```

```text
1.0f / sqrtf(x)            3.019 ns per value
guess + 1 Newton (Quake)   5.041 ns per value
rsqrtss                    3.113 ns per value
rsqrtss + 1 Newton         3.063 ns per value
```

والنتيجة على هذا المعالج واضحة: الحيلة هي الأبطأ بين الأربعة، 5.04 نانوثانية لكل عدد، بينما القسمة العادية على الجذر 3.02، وrsqrtss وحده 3.11، وrsqrtss مع خطوة نيوتن 3.06\. والأرقام الثلاثة المتقاربة حول 3 نانوثوان تعني أن الحلقة نفسها، أي قراءة العدد وكتابة الناتج والعد، هي التي تحدد الزمن هنا، وأن الجذر والقسمة في معالج اليوم لم يعودا العائق الذي كانا عليه في 1999\. أما الحيلة فتحتاج أوامر أكثر: نقل البتات من سجل عشري إلى سجل صحيح، والإزاحة، والطرح، والنقل مرة أخرى، ثم أربع عمليات حساب، وكل ذلك أكثر مما يحتاجه أمر جذر واحد في العتاد.

وتذكر صفحة Wikipedia قياساً من 2009 على معالج Core 2 أعطى rsqrtss 0.85 نانوثانية للعدد مقابل 3.54 للحيلة، فالنتيجة نفسها تتكرر منذ أكثر من خمس عشرة سنة. والشكل التالي يجمع الخطأ والسرعة معاً:

![رسمان: على اليمين أكبر خطأ نسبي بمقياس لوغاريتمي لست نسخ من التخمين وحده 3.44% إلى rsqrtss مع نيوتن 0.00003%، وعلى اليسار الزمن بالنانوثانية لأربع نسخ: 1.0f / sqrtf(x) 3.02 والحيلة 5.04 وrsqrtss 3.11 وrsqrtss مع نيوتن 3.06](https://arabroot.io/content/images/2026/11/fast-inverse-sqrt-04-results.webp)

rsqrtss مع خطوة نيوتن أدق من الحيلة بستة آلاف مرة، وأسرع منها على هذا الجهاز.

![معالج Intel Pentium III بغلاف خرطوشة أسود طويل من نوع Slot 1 عليه شعار Pentium III ذهبي](https://arabroot.io/content/images/2026/11/fast-inverse-sqrt-pentium3-photo.webp)

معالج Pentium III بغلاف Slot 1، الجيل الذي جاء بمجموعة SSE والأمر rsqrtss عام 1999، أي في السنة نفسها التي صدرت فيها Quake III. الصورة: Appaloosa، رخصة CC BY-SA 3.0، المصدر: [Wikimedia Commons](https://commons.wikimedia.org/wiki/File:Intel%5FPentium%5FIII%5FKatmai.jpg?ref=arabroot.io) (تم تصغيرها).

## ماذا لو كتبناها في Python أو JavaScript؟

الحيلة تحتاج قراءة بتات float كعدد صحيح، وهذا ليس طبيعياً في لغات لا تعطيك الذاكرة مباشرة. ففي Python نستخدم الوحدة struct لنحزم العدد في 4 بايتات ونفكها كعدد صحيح، وفي JavaScript نستخدم مصفوفتين، Float32Array وUint32Array، تشتركان في الذاكرة نفسها، وMath.fround لنقرب كل خطوة إلى دقة float كما في C:

```python
# rsqrt.py: the same trick in Python, with struct to move between float bits and an integer.
import struct, math, sys, time

def bits_of(f):  return struct.unpack("<I", struct.pack("<f", f))[0]
def float_of(i): return struct.unpack("<f", struct.pack("<I", i & 0xFFFFFFFF))[0]
def f32(v):      return struct.unpack("<f", struct.pack("<f", v))[0]   # round to float32 like C

def rsqrt(x, magic=0x5f3759df):
    y = float_of(magic - (bits_of(x) >> 1))
    return f32(y * f32(1.5 - f32(f32(0.5 * x) * y * y)))

for s in sys.argv[1:] or ["4", "2", "0.15625", "100"]:
    x = f32(float(s))
    print(f"x = {x:<10g} trick {rsqrt(x):.9f}  bits 0x{bits_of(rsqrt(x)):08x}  exact {1 / math.sqrt(x):.9f}")

xs = [f32(0.001 + i * 0.37) for i in range(200_000)]
for name, fn in (("trick", rsqrt), ("1/math.sqrt", lambda x: 1 / math.sqrt(x))):
    t = time.perf_counter(); [fn(x) for x in xs]; print(f"{name:12} {(time.perf_counter() - t) / len(xs) * 1e9:.0f} ns per value")
```

```javascript
// rsqrt.mjs: the same trick in JavaScript: a Float32Array and a Uint32Array share one 4-byte buffer.
const buf = new ArrayBuffer(4), f = new Float32Array(buf), u = new Uint32Array(buf);
function rsqrt(x, magic = 0x5f3759df) {
  f[0] = x;
  u[0] = (magic - (u[0] >>> 1)) >>> 0;          // >>> keeps the result unsigned
  const y = f[0];
  return Math.fround(y * Math.fround(1.5 - Math.fround(Math.fround(0.5 * x) * y * y)));
}
const hex = (v) => { f[0] = v; return "0x" + u[0].toString(16).padStart(8, "0"); };
for (const s of process.argv.slice(2).length ? process.argv.slice(2) : ["4", "2", "0.15625", "100"]) {
  const x = Math.fround(Number(s));
  console.log(`x = ${String(x).padEnd(10)} trick ${rsqrt(x).toFixed(9)}  bits ${hex(rsqrt(x))}  exact ${(1 / Math.sqrt(x)).toFixed(9)}`);
}
const xs = Float32Array.from({ length: 1_000_000 }, (_, i) => 0.001 + i * 0.37);
// one loop per function: a shared loop that calls "fn" would measure the indirect call, not the math
function timeTrick() { let s = 0; for (let i = 0; i < xs.length; i++) s += rsqrt(xs[i]); return s; }
function timeSqrt() { let s = 0; for (let i = 0; i < xs.length; i++) s += 1 / Math.sqrt(xs[i]); return s; }
for (const [name, run] of [["trick", timeTrick], ["1/Math.sqrt", timeSqrt]]) {
  let best = Infinity;
  for (let r = 0; r < 5; r++) { const t = performance.now(); run(); best = Math.min(best, performance.now() - t); }
  console.log(`${name.padEnd(12)} ${(best / xs.length * 1e6).toFixed(2)} ns per value`);
}
```

والمخرجان، وقد شغلناهما على الجهاز نفسه خارج الـ Container:

```text
# Windows 11 host, Python 3.13.3
x = 4          trick 0.499153584  bits 0x3eff910f  exact 0.500000000
x = 2          trick 0.706930041  bits 0x3f34f95e  exact 0.707106781
x = 0.15625    trick 2.525486231  bits 0x4021a191  exact 2.529822128
x = 100        trick 0.099844880  bits 0x3dcc7b79  exact 0.100000000
trick        4576 ns per value
1/math.sqrt  531 ns per value
```

```text
# Windows 11 host, Node v22.14.0
x = 4          trick 0.499153584  bits 0x3eff910f  exact 0.500000000
x = 2          trick 0.706930041  bits 0x3f34f95e  exact 0.707106781
x = 0.15625    trick 2.525486231  bits 0x4021a191  exact 2.529822128
x = 100        trick 0.099844880  bits 0x3dcc7b79  exact 0.100000000
trick        9.44 ns per value
1/Math.sqrt  4.07 ns per value
```

في المخرجين أعلاه لاحظ التالي:

- البتات متطابقة في اللغات الثلاث: العدد 4 أعطى 0x3eff910f، أي 0.499153584، وهي القيمة نفسها التي طبعها برنامج C. وهذا يؤكد أن الحيلة تعريف دقيق على البتات، لا شيء يعتمد على اللغة، بشرط أن تقرب كل عملية إلى float.
- في Python الحيلة أبطأ من الجذر العادي بتسع مرات تقريباً، 4,576 نانوثانية مقابل 531، لأن كل عملية struct استدعاء دالة كامل، بينما math.sqrt أمر واحد في C تحت الغطاء.
- وفي JavaScript أبطأ بمرتين وثلث، 9.44 مقابل 4.07، رغم أن محرك V8 يترجم الكود إلى لغة الآلة، لأن الكتابة في المصفوفتين والقراءة منهما تمر بالذاكرة.

⚠️

في أول قياس لـ JavaScript كتبنا حلقة واحدة تستدعي الدالتين عبر متغير، فظهر أن 1/Math.sqrt أبطأ من الحيلة بخمس مرات، 93 نانوثانية مقابل 18\. والسبب لم يكن الجذر، وإنما الاستدعاء عبر متغير يتغير بين دالتين، فلم يستطع المحرك تحسين الحلقة. وحين كتبنا حلقة مستقلة لكل دالة، كما في الملف أعلاه، انقلبت النتيجة. وهذا درس في القياس Benchmarking أكثر منه في الجذر: تأكد أن ما تقيسه هو العملية نفسها، لا طريقة استدعائها.

## ماذا لو نسخت الكود الأصلي على نظام 64 بت؟

الكود الأصلي يقرأ بتات float في متغير من نوع long عبر تحويل مؤشر. وفي 1999 على Windows وأنظمة 32 بت كان long يساوي 4 بايتات مثل float تماماً، ولكن على Linux بنظام 64 بت صار long ثمانية بايتات. وكتبنا في longbug.c نسخة بالفكرة نفسها لنرى ماذا يحدث:

```c
/* longbug.c: the original code reads the float through a "long". On 64-bit Linux a long is 8 bytes. */
#include <stdio.h>
float rsqrt_long(float number) {
    long i; float x2 = number * 0.5f, y = number;
    i = *(long *)&y;                     /* reads 8 bytes from a 4-byte float */
    i = 0x5f3759df - (i >> 1);
    y = *(float *)&i;
    return y * (1.5f - x2 * y * y);
}
int main(void) {
    printf("sizeof(long) = %zu, sizeof(float) = %zu\n", sizeof(long), sizeof(float));
    float xs[] = {4.0f, 2.0f, 100.0f};
    for (int k = 0; k < 3; k++) printf("x = %-5g -> %.9g (expected about %.4f)\n", xs[k], rsqrt_long(xs[k]), k == 0 ? 0.5 : k == 1 ? 0.7071 : 0.1);
    return 0;
}
```

```text
--- -O2 -Wall on longbug.c
longbug.c: In function 'rsqrt_long':
longbug.c:5:10: warning: dereferencing type-punned pointer will break strict-aliasing rules [-Wstrict-aliasing]
    5 |     i = *(long *)&y;                     /* reads 8 bytes from a 4-byte float */
      |          ^~~~~~~~~~
longbug.c:7:10: warning: dereferencing type-punned pointer will break strict-aliasing rules [-Wstrict-aliasing]
    7 |     y = *(float *)&i;
      |          ^~~~~~~~~~~
longbug.c:5:9: warning: 'y' is used uninitialized [-Wuninitialized]
    5 |     i = *(long *)&y;                     /* reads 8 bytes from a 4-byte float */
      |         ^~~~~~~~~~~
longbug.c:4:39: note: 'y' declared here
    4 |     long i; float x2 = number * 0.5f, y = number;
      |                                       ^
longbug.c:5:9: warning: array subscript 'long int[0]' is partly outside array bounds of 'float[1]' [-Warray-bounds=]
    5 |     i = *(long *)&y;                     /* reads 8 bytes from a 4-byte float */
      |         ^~~~~~~~~~~
longbug.c:4:39: note: object 'y' of size 4
    4 |     long i; float x2 = number * 0.5f, y = number;
      |                                       ^
In function 'rsqrt_long',
    inlined from 'main' at longbug.c:13:91:
longbug.c:5:9: warning: array subscript 'long int[0]' is partly outside array bounds of 'float[1]' [-Warray-bounds=]
    5 |     i = *(long *)&y;                     /* reads 8 bytes from a 4-byte float */
      |         ^~~~~~~~~~~
longbug.c: In function 'main':
longbug.c:4:39: note: object 'y' of size 4
    4 |     long i; float x2 = number * 0.5f, y = number;
      |                                       ^
sizeof(long) = 8, sizeof(float) = 4
x = 4     -> 0.499153584 (expected about 0.5000)
x = 2     -> 0.706930041 (expected about 0.7071)
x = 100   -> 0.0998448804 (expected about 0.1000)
--- -O0
sizeof(long) = 8, sizeof(float) = 4
x = 4     -> 0.499153584 (expected about 0.5000)
x = 2     -> 0.706930041 (expected about 0.7071)
x = 100   -> 0.0998448804 (expected about 0.1000)
```

والنتيجة أخطر مما تبدو: الأرقام صحيحة في الحالتين. فالمترجم حذر بأربعة أنواع من التحذيرات Warnings: مخالفة قاعدة Strict Aliasing، والقراءة خارج حدود المتغير لأن البرنامج يقرأ 8 بايتات من متغير حجمه 4، وأن y مستخدم قبل تهيئته، لأن المترجم لم يعد يرى أن القراءة عبر long تخص y. ومع ذلك خرجت الأرقام صحيحة، والسبب حظ فقط: البايتات الأربعة الزائدة التي قرأها البرنامج من الذاكرة بعد y كان أدنى بت فيها صفراً. فالإزاحة لليمين تنقل البت 32 إلى البت 31، وهو بت الإشارة في float الناتج، فلو كان واحداً لخرج الجواب سالباً. أي أن الكود يعمل اليوم وقد يفشل غداً بتغيير بسيط في ترتيب المتغيرات أو في خيارات المترجم. ولذلك لا تقم بنسخ هذه الطريقة في القراءة أبداً، واستخدم memcpy في C، أو std::bit\_cast في C++20 كما تقترح صفحة Wikipedia، أو uint32\_t بحجم مضمون بدل long.

## الأخطاء التي تتكرر

- **استخدام الحيلة اليوم بحجة السرعة:** على معالجنا كانت الأبطأ بين أربع طرق، وفي Python وJavaScript أبطأ من الجذر العادي بكثير. قس قبل أن تحسن، كما في [مقال قياس أداء اللعبة](https://arabroot.io/articles/%D8%A7%D8%AF%D8%A7%D8%A1-%D8%A7%D9%84%D9%84%D8%B9%D8%A8%D8%A9-%D9%82%D9%8A%D8%A7%D8%B3-%D8%A7%D9%84%D8%A7%D8%B7%D8%A7%D8%B1%D8%A7%D8%AA-profiling-%D9%88%D8%AA%D8%AD%D8%B3%D9%8A%D9%86%D9%87%D8%A7/).
- **قراءة البتات بتحويل المؤشر:** سلوك غير معرف Undefined Behavior في C وC++، ورأينا كيف حذر المترجم بأربعة تحذيرات، وكيف يعتمد الناتج على بايتات لا تملكها. استخدم memcpy أو std::bit\_cast.
- **استخدام long بدل نوع بحجم مضمون:** حجم long يختلف بين Windows وLinux وبين 32 و64 بت. استخدم uint32\_t.
- **إدخال صفر أو عدد سالب أو NaN:** الحيلة لا تتحقق من شيء، فالصفر يعطي عدداً كبيراً بدل اللانهاية، والسالب يعطي قيمة بلا معنى. وحد المتجه ذا الطول الصفر قبل أن تستدعيها، كما ذكرنا في مقال رياضيات الألعاب.
- **الوثوق بأمثلة قليلة:** أربعة أمثلة أعطت خطأ حول 0.17%، والقياس الشامل أعطى 0.1752% كأكبر خطأ، وهو قريب، ولكن الأعداد الأربعة لم تكن لتكشف أن الخطأ في جهة واحدة دائماً. إذا كان المدى محدوداً مثل float فقسه كله.
- **قياس السرعة بحلقة غير عادلة:** في JavaScript غير الاستدعاء عبر متغير النتيجة خمس مرات. اكتب حلقة مستقلة لكل طريقة، وخذ أفضل عدة تشغيلات.

## ماذا تستخدم اليوم؟ جدول قرار Decision Table

| الحالة                                            | الأنسب                                   | السبب من المختبر                                      |
| ------------------------------------------------- | ---------------------------------------- | ----------------------------------------------------- |
| كود عادي في محرك أو تطبيق                         | 1.0f / sqrtf(x) أو دالة المحرك normalize | 3.02 نانوثانية ودقة كاملة، والمترجم يعرف أفضل الأوامر |
| حلقة حارة على x86 تقبل دقة 0.03%                  | rsqrtss أو نسخته المتجهة                 | 3.11 نانوثانية وخطأ 0.0326%                           |
| تحتاج دقة قريبة من الكاملة بسرعة                  | rsqrtss مع خطوة نيوتن                    | 3.06 نانوثانية وخطأ 0.00003%                          |
| معالج صغير بلا جذر في العتاد ولا وحدة عشرية سريعة | الحيلة بثوابت Kadlec أو 0x5f375a86       | عمليات صحيحة وضرب فقط، وخطأ 0.065%                    |
| Python أو JavaScript                              | الجذر العادي دائماً                      | الحيلة أبطأ بتسع مرات في Python ومرتين في Node        |
| التعليم وفهم float                                | الحيلة نفسها                             | أوضح مثال على أن بتات العدد لوغاريتمه                 |

## ماذا يبقى من الحيلة اليوم؟

لم تعد الحيلة مفيدة لسرعتها في أغلب الأجهزة، والسبب ليس أن أحداً وجد حيلة أفضل، وإنما أن مصممي المعالجات رأوا الحاجة نفسها ووضعوها في العتاد: rsqrtss في SSE، ونسخها المتجهة التي تحسب أربعة أعداد أو أكثر في أمر واحد، وأوامر مشابهة في معالجات ARM وفي شرائح الرسوم. وقد شرحنا في [مقال كيف يعمل المعالج من الداخل](https://arabroot.io/articles/%D9%83%D9%8A%D9%81-%D9%8A%D8%B9%D9%85%D9%84-%D8%A7%D9%84%D9%85%D8%B9%D8%A7%D9%84%D8%AC-cpu-%D9%85%D9%86-%D8%A7%D9%84%D8%AF%D8%A7%D8%AE%D9%84/) كيف تحسب أوامر SIMD عدة أرقام معاً، وهذا هو الطريق الذي سلكته الصناعة لما كانت الحيلة تحاول حله. وفي لغات الظلال Shading Languages التي تكتب بها برامج شريحة الرسوم صار 1 على الجذر دالة جاهزة باسمها، inversesqrt في GLSL وrsqrt في HLSL، لأن توحيد المتجهات العمودية في كل بكسل هو أكثر ما تفعله برامج الإضاءة. أي أن العملية التي احتاجت حيلة على البتات في 1999 صارت اليوم أمراً واحداً في العتاد، تستدعيه دون أن تفكر فيه، ويحسب لعشرات البكسلات في وقت واحد.

ولكن الفكرة وراءها باقية وتستحق أن تعرفها: أن تمثيل الرقم في الذاكرة ليس مجرد تخزين، وإنما يحمل بنية رياضية يمكن استغلالها. فالبتات العليا في float هي لوغاريتم تقريبي، وهذا يفسر لماذا تصلح مقارنة عددين موجبين من float كأنهما عددان صحيحان، ولماذا تعمل حيل مشابهة لحساب اللوغاريتم والأس التقريبيين في مكتبات الشبكات العصبية التي تقبل دقة أقل مقابل السرعة. والفكرة الثانية أعم: تقريب رخيص ثم خطوة تصحيح، وهو نمط تجده في كل مكان، من خوارزميات القسمة داخل المعالج نفسه إلى الحلول التكرارية في الرياضيات الحسابية.

## تطبيق عملي

1. عدل cmd\_search ليبحث أيضاً بعد خطوتي نيوتن، وانظر هل يبقى الثابت الأفضل 0x5f375a87، أم يتحرك؟
2. اكتب نسخة الحيلة لنوع double بـ 64 بتاً، وابحث عن الرقم السحري المقابل بالمعادلة في هذا المقال مع 2 مرفوعة إلى 52 و1023 بدل 23 و127، ثم قس خطأها على عينة كبيرة.
3. جرب ثوابت خطوة نيوتن في نسخة Kadlec بقيم قريبة، مثلاً 0.7039 و2.3892، وقس كيف يتغير أكبر خطأ على المدى من 1 إلى 4.
4. جمع rsqrt.c دون `-fno-tree-vectorize` وبالخيار `-O3 -march=native`، وقس السرعة مرة أخرى. أي النسخ استفادت من أوامر المتجهات؟

## الخلاصة Summary

- الألعاب تحتاج 1 على الجذر لتوحيد طول المتجهات في كل إطار، والجذر والقسمة كانا من أبطأ العمليات في 1999.
- بتات float إذا قرأتها كعدد صحيح تقارب لوغاريتمه للأساس 2، فيصبح 1 على الجذر إزاحة لليمين بتاً وطرحاً من ثابت، والثابت 0x5f3759df هو 1.5 في 2 مرفوعة إلى 23 في (127 ناقص 0.045).
- التخمين وحده خطؤه حتى 3.44%، وخطوة نيوتن واحدة تنزله إلى 0.1752%، واثنتان إلى 0.0005%، وثوابت Kadlec إلى 0.065%، كما قسنا على 2,130,706,432 عدداً موجباً.
- بحثنا أعاد نتائج Lomont: 0x5f37642f الأفضل للتخمين وحده، و0x5f375a87 بعد نيوتن، والأصلي أسوأ منه بواحد من مليون فقط.
- على معالج اليوم كانت الحيلة الأبطأ: 5.04 نانوثانية مقابل 3.02 للقسمة العادية و3.06 لـ rsqrtss مع نيوتن الأدق منها بآلاف المرات. ونسخها الأصلية بـ long تعتمد على الحظ على أنظمة 64 بت.

وبهذا نكون قد أنهينا حيل هذه المرحلة، من المسدس الضوئي إلى شجرة Doom إلى هذا السطر، وكلها تقول الشيء نفسه بطرق مختلفة: افهم ما يفعله العتاد بالضبط، ثم اعمل معه لا ضده:

[![](https://arabroot.io/content/images/2026/11/doom-bsp-cover-cover.webp)دليلكيف رسمت Doom عالماً ثلاثي الأبعاد بشجرة BSP؟نشرح كيف رتبت Doom جدرانها بشجرة BSP ورسمتها من القريب إلى البعيد، ونبني الشجرة والمرسم بـ Python ونعد ما يفحصه كل أسلوب على خرائط حتى 1,225 جداراً.](https://arabroot.io/articles/%D9%83%D9%8A%D9%81-%D8%B1%D8%B3%D9%85%D8%AA-doom-%D8%B9%D8%A7%D9%84%D9%85%D8%A7-%D8%AB%D9%84%D8%A7%D8%AB%D9%8A-%D8%A7%D9%84%D8%A7%D8%A8%D8%B9%D8%A7%D8%AF-%D8%A8%D8%B4%D8%AC%D8%B1%D8%A9-bsp/)[![](https://arabroot.io/content/images/2026/11/sprite-flicker-limits-cover-cover.webp)دليللماذا كانت الشخصيات ترمش؟ حدود رسوميات NESنشرح لماذا لا يرسم جهاز NES أكثر من ثماني شخصيات في السطر، ونكتب ROM صغيراً يزدحم عمداً ونقيس في FCEUX أي طريقة رمش توزع الاختفاء بعدل.](https://arabroot.io/articles/%D9%84%D9%85%D8%A7%D8%B0%D8%A7-%D9%83%D8%A7%D9%86%D8%AA-%D8%A7%D9%84%D8%B4%D8%AE%D8%B5%D9%8A%D8%A7%D8%AA-%D8%AA%D8%B1%D9%85%D8%B4-%D8%AD%D8%AF%D9%88%D8%AF-%D8%B1%D8%B3%D9%88%D9%85%D9%8A%D8%A7%D8%AA-nes/)[![](https://arabroot.io/content/images/2026/11/game-math-cover-cover.webp)دليلرياضيات الألعاب: المتجهات Vectors والحركة والتصادمالمتجهات والحركة وحاصل الضرب النقطي واختبارات التصادم والارتداد والنفق، بلعبة صغيرة ومختبر Python يصنع الأخطاء الشائعة ثم يصلحها.](https://arabroot.io/articles/%D8%B1%D9%8A%D8%A7%D8%B6%D9%8A%D8%A7%D8%AA-%D8%A7%D9%84%D8%A7%D9%84%D8%B9%D8%A7%D8%A8-%D8%A7%D9%84%D9%85%D8%AA%D8%AC%D9%87%D8%A7%D8%AA-vectors-%D9%88%D8%A7%D9%84%D8%AD%D8%B1%D9%83%D8%A9-%D9%88%D8%A7%D9%84%D8%AA%D8%B5%D8%A7%D8%AF%D9%85/)[![](https://arabroot.io/content/images/2026/11/floating-point-cover-cover.webp)دليلFloating Point من الداخل: كيف يخزن الحاسب الكسوركيف يحفظ معيار IEEE 754 الكسور في البتات، ولماذا تكبر الفجوة بين الأرقام وتضيع خانات المعرفات، ومتى تحتاج النوع العشري.](https://arabroot.io/articles/%D8%A7%D9%84%D8%A3%D8%B1%D9%82%D8%A7%D9%85-%D8%A7%D9%84%D8%B9%D8%B4%D8%B1%D9%8A%D8%A9-floating-point-%D9%85%D9%86-%D8%A7%D9%84%D8%AF%D8%A7%D8%AE%D9%84/)

## سجل التحديثات Changelog

- 20 نوفمبر 2026: كتابة المقال، وتشغيل المختبر على gcc 14.2.0 داخل alpine:3.22 على Intel Core i7-7700K، وPython 3.13.3 وNode.js 22.14.0 على Windows 11.