الفرق بين المراجعتين لصفحة: «Ruby/Float»

من موسوعة حسوب
→ التعديل السابق
مرئينص الويكي
لا ملخص تعديل
مراجعة وتدقيق.
 
سطر 1: سطر 1:
<noinclude>{{DISPLAYTITLE: الصنف Float في روبي}}</noinclude>
<noinclude>{{DISPLAYTITLE: الصنف <code>Float</code> في روبي}}</noinclude>
تمثِّل كائنات الصنف Float أعدادًا حقيقيةً غير دقيقة (inexact real numbers) باستخدام التمثيل العشري ذي الدقة المضاعفة للبنية الأصلية.
تمثِّل كائنات الصنف <code>Float</code> أعدادًا حقيقيةً غير دقيقة (inexact real numbers) باستخدام التمثيل العشري ذي الدقة المضاعفة للبنية الأصلية.


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


* [[docs.sun.com/source/806-3568/ncg_goldberg.html]]
* [https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html ما هي الأشياء التي يجب أن يعرفها كل عالم حاسوب عن الأعداد العشرية].


* [[wiki.github.com/rdp/ruby_tutorials_core/ruby-talk-faq#wiki-floats_imprecise]]
* [https://github.com/rdp/ruby_tutorials_core/wiki/ruby-talk-faq#floats_imprecise لماذا الأعداد العشرية في روبي غير دقيقة؟]


* [[en.wikipedia.org/wiki/Floating_point#Accuracy_problems]]
* [[wikipedia:Floating-point_arithmetic#Accuracy_problems|مشاكل في الدقة]].
===الثوابت===
==الثوابت==
====<code>DIG</code>====
===<code>DIG</code>===
الحد الأدنى لعدد الأرقام العشرية ذات الدلالة في النقطة العائمة المزدوجة الدقة.
الحد الأدنى لعدد الأرقام العشرية ذات الدلالة في المنازل العشرية المزدوجة الدقة. وعادةً ما تكون قيمته الافتراضية <code>15</code>.
===<code>EPSILON</code>===
الفرق بين <code>1</code> و أصغر عدد عشري ذي دقة مضاعفة أكبر من <code>1</code> من نوع النقطة العائمة المزدوجة الدقة. وعادة ما تكون قيمته الافتراضية هي <code>2.2204460492503131e-16</code>.
===<code>INFINITY</code>===
يمثل اللانهاية الموجبة.
===<code>MANT_DIG</code>===
عدد الأرقام الأساسية للأعداد العشرية المضاعفة (أي البيانات ذات النوع double). وعادةً ما تكون قيمته الافتراضية هي <code>53</code>.
===<code>MAX</code>===
أكبر عدد صحيح في العدد العشري ذي الدقة المضاعفة. وعادةً ما تكون قيمته الافتراضية <code>1.7976931348623157e+308</code>.
===<code>MAX_10_EXP</code>===
أكبر أس موجب في العدد العشري ذي الدقة المضاعفة حيث تكون القيمة <code>10</code> مرفوعة إلى هذا الأس بعد طرح القيمة <code>1</code> منها. وعادةً ما تكون قيمته الافتراضية هي <code>308</code>.
===<code>MAX_EXP</code>===
أكبر قيمة أس محتملة في العدد العشري ذي الدقة المضاعفة. وعادةً ما تكون قيمته الافتراضية هي <code>1024</code>.
===<code>MIN</code>===
أصغر رقم طبيعي ([[wikipedia:Normalized_number|normalized number]]) موجب في العدد العشري ذي الدقة المضاعفة. وعادة ما تكون قيمته الافتراضية <code>2.2250738585072014e-308</code>.


وعادة ما تكون قيمته الافتراضية <code>15</code>.
إذا كانت المنصة تدعم الأعداد غير الطبيعية ([[wikipedia:Denormal_number|denormalized numbers]])، فسيكون هناك أرقام بين الصفر والقيمة <code>Float::MIN</code>. وتعيد <code>‎0.0.next_float</code> أصغر عدد عشري موجب بما في ذلك الأعداد غير الطبيعية ([[wikipedia:Denormal_number|denormalized numbers]]).
====<code>EPSILON</code>====
===<code>MIN_10_EXP</code>===
الفرق بين <code>1</code> و أصغر عدد أكبر من <code>1</code> من نوع النقطة العائمة المزدوجة الدقة.
أصغر أس سالب في العدد العشري ذي الدقة المضاعفة إذ تكون <code>10</code> مرفوعة إلى هذا الأس ناقص <code>1</code>. وعادةً ما تكون قيمته الافتراضية <code>‎-307</code>.
 
===<code>MIN_EXP</code>===
وعادة ما تكون قيمته الافتراضية <code>2.2204460492503131e-16</code>.
أصغر قيمة أس محتملة في العدد العشري ذي الدقة المضاعفة. وعادةً ما تكون قيمته الافتراضية <code>‎-1021</code>.
====<code>INFINITY</code>====
===<code>NAN</code>===
تعبير يمثل اللانهاية الموجبة.
====<code>MANT_DIG</code>====
عدد الأرقام الأساسية لنوع البيانات المزدوج (double).
 
وعادة ما تكون قيمته الافتراضية <code>53</code>.
====<code>MAX</code>====
أكبر عدد صحيح في النقطة العائمة المزدوجة الدقة.
 
وعادة ما تكون قيمته الافتراضية <code>1.7976931348623157e+308</code>.
====<code>MAX_10_EXP</code>====
أكبر أس موجب في النقطة العائمة المزدوجة الدقة حيث تكون <code>10</code> مرفوعة إلى هذا الأس ناقص <code>1</code>.
 
وعادة ما تكون قيمته الافتراضية <code>308</code>.
====<code>MAX_EXP</code>====
أكبر قيمة أس محتملة في النقطة العائمة المزدوجة الدقة.
 
وعادة ما تكون قيمته الافتراضية <code>1024</code>.
====<code>MIN</code>====
أصغر رقم مُعيَّر موجب في النقطة العائمة المزدوجة الدقة.
 
وعادة ما تكون قيمته الافتراضية <code>2.2250738585072014e-308</code>.
 
إذا كانت المنصة تدعم الأرقام غير المُعيَّرة، يكون هناك أرقام بين صفر و <code>Float::MIN</code>. وتعيد <code>‎0.0.next_float</code> أصغر نقطة عائمة موجبة بما في ذلك الأرقام غير المُعيَّرة.
====<code>MIN_10_EXP</code>====
أصغر أس سالب في النقطة العائمة المزدوجة الدقة حيث تكون <code>10</code> مرفوعة إلى هذا الأس ناقص <code>1</code>.
 
وعادة ما تكون قيمته الافتراضية <code>‎-307</code>.
====<code>MIN_EXP</code>====
أصغر قيمة أس محتملة في النقطة العائمة المزدوجة الدقة.
 
وعادة ما تكون قيمته الافتراضية <code>‎-1021</code>.
====<code>NAN</code>====
تعبير يمثل القيمة "ليست عددًا" (not a number).
تعبير يمثل القيمة "ليست عددًا" (not a number).
====<code>RADIX</code>====
===<code>RADIX</code>===
أساس النقطة العائمة، أو عدد الأرقام الفريدة المستخدمة لتمثيل الرقم.
أساس العدد العشري، أو عدد الأرقام الفريدة المستخدمة لتمثيل العدد. وعادةً ما تكون قيمته الافتراضية <code>2</code> على معظم الأنظمة، والتي تمثل النظام العشري ذي الأساس <code>10</code>.
 
===<code>ROUNDS</code>===
وعادة ما تكون قيمته الافتراضية <code>2</code> على معظم الأنظمة، والتي تمثل النظام العشري للأساس <code>10</code>.
يمثل وضع التقريب لإضافة المنازل العشرية. وعادةً ما تكون قيمته الافتراضية <code>1</code>، التقريب إلى أقرب عدد.
====<code>ROUNDS</code>====
يمثل وضع التقريب لإضافة النقطة العائمة.
 
وعادة ما تكون قيمته الافتراضية <code>1</code>، التقريب إلى أقرب عدد.


وتشمل الأوضاع الأخرى:
وتشمل الأوضاع الأخرى:
* ‎<code>-1</code>: مُتعذِّر تحديده.


‎<code>-1</code> : مُتعذِّر تحديده.
* <code>0</code>: التقريب نحو الصفر.


<code>0</code> : التقريب نحو الصفر.
* <code>1</code>: التقريب إلى أقرب عدد.


<code>1</code> : التقريب إلى أقرب عدد.
* <code>2</code>: التقريب نحو اللانهاية الموجبة.


<code>2</code> : التقريب نحو اللانهاية الموجبة.
* <code>3</code>: التقريب نحو اللانهاية السالبة.


<code>3</code> : التقريب نحو اللانهاية السالبة.
=توابع النسخة العامة=
===توابع المثيل العام===
===<code>[[Ruby/Float/mod|%]]</code>===
===<code>[[Ruby/Float/modulo|%]]</code>===
يعيد باقي عملية قسمة عدد عشري على عدد آخر.
يعيد المعامل <code>%‎</code> باقي عملية قسمة عدد عشري على عدد آخر.


===<code>[[Ruby/Float/multiplication|*]]</code>===
===<code>[[Ruby/Float/multiplication|*]]</code>===
يعيد المعامل <code>*‎</code> ناتج عملية ضرب عدد عشري بعدد آخر.
يعيد ناتج عملية ضرب عدد عشري بعدد آخر.


===<code>[[Ruby/Float/expo|**]]</code>===
===<code>[[Ruby/Float/expo|**]]</code>===
يعيد المعامل <code>**‎</code> ناتج عملية رفع عدد عشري (الأساس) إلى قوة عدد محدد (الأس).
يعيد ناتج عملية رفع عدد عشري (الأساس) إلى قوة عدد محدد (الأس).


===<code>[[Ruby/Float/plus|+]]</code>===
===<code>[[Ruby/Float/plus|+]]</code>===
يعيد المعامل <code>+</code> ناتج عملية الجمع بين عددين.
يعيد ناتج عملية الجمع بين عددين.


===<code>[[Ruby/Float/minus|-]]</code>===
===<code>[[Ruby/Float/minus|-]]</code>===
يعيد المعامل <code>-‎</code> ناتج عملية الطرح بين عددين.
يعيد ناتج عملية الطرح بين عددين.


===<code>[[Ruby/Float/negation|-]]</code>===
===<code>[[Ruby/Float/negation|-]]</code>===
إن استُعمِل المعامل <code>-</code> بالشكل <code>‎-Float</code>، فسيعيد القيمة المعاكسة للعدد <code>Float</code> العشري (أي القيمة السالبة إن كان <code>Float</code> موجبًا أو العكس بالعكس).
إن استُعمِل هذا المعامل بالشكل <code>‎-Float</code>، فسيعيد القيمة المعاكسة للعدد <code>Float</code> العشري (أي القيمة السالبة إن كان <code>Float</code> موجبًا أو العكس بالعكس).


===<code>[[Ruby/Float/division|/]]</code>===
===<code>[[Ruby/Float/division|/]]</code>===
يعيد المعامل <code>/‎</code> ناتج عملية القسمة بين عدد عشري وعدد آخر.
يعيد ناتج عملية القسمة بين عدد عشري وعدد آخر.


===<code>[[Ruby/Float/lt|>]]</code>===
===<code>[[Ruby/Float/lt|>]]</code>===
يعيد المعامل <code>></code> القيمة <code>true</code> إن كانت قيمة العدد العشري الواقع على يساره أصغر من قيمة العدد المواقع على يمينه.
يعيد القيمة <code>true</code> إن كانت قيمة العدد العشري الواقع على يساره أصغر من قيمة العدد المواقع على يمينه.


===<code>[[Ruby/Float/le|=>]]</code>===
===<code>[[Ruby/Float/le|=>]]</code>===
يعيد المعامل <code>=></code> القيمة <code>true</code> إن كانت قيمة العدد العشري الواقع على يساره أصغر من أو تساوي قيمة العدد الواقع على يمينه.
يعيد القيمة <code>true</code> إن كانت قيمة العدد العشري الواقع على يساره أصغر من أو تساوي قيمة العدد الواقع على يمينه.


===<code>[[Ruby/Float/comparison|<=>]]</code>===
===<code>[[Ruby/Float/comparison|<=>]]</code>===
يعيد معامل الموازنة <code><=></code> عددً‎ا صحيحًا (‎-1 أو 0 أو ‎+1) إذا كان العدد العشري الواقع على يساره أصغر من أو يساوي أو أكبر من العدد الآخر الواقع على يمينه على التوالي.
يعيد عددً‎ا صحيحًا (‎-1 أو 0 أو ‎+1) إذا كان العدد العشري الواقع على يساره أصغر من أو يساوي أو أكبر من العدد الآخر الواقع على يمينه على التوالي.


===<code>[[Ruby/Float/equal|==]]</code>===
===<code>[[Ruby/Float/equal|==]]</code>===
يعيد المعامل <code>==</code> القيمة <code>true</code> إن كان العدد العشري الواقع على يساره يساوي القيمة الواقعة على يمينه. 
يعيد القيمة <code>true</code> إن كان العدد العشري الواقع على يساره يساوي القيمة الواقعة على يمينه. 


===<code>[[Ruby/Float/gt|<]]</code>===
===<code>[[Ruby/Float/gt|<]]</code>===
يعيد المعامل <code><</code> القيمة <code>true</code> إن كانت قيمة العدد العشري الواقع على يساره أكبر من قيمة العدد الآخر الواقع على يمينه.
يعيد القيمة <code>true</code> إن كانت قيمة العدد العشري الواقع على يساره أكبر من قيمة العدد الآخر الواقع على يمينه.


===<code>[[Ruby/Float/ge|=<]]</code>===
===<code>[[Ruby/Float/ge|=<]]</code>===
يعيد التابع <code>=<</code> القيمة <code>true</code> إن كانت قيمة العدد العشري الواقع على يساره أكبر من أو تساوي قيمة العدد الآخر الواقع على يمينه.
يعيد القيمة <code>true</code> إن كانت قيمة العدد العشري الواقع على يساره أكبر من أو تساوي قيمة العدد الآخر الواقع على يمينه.


===<code>[[Ruby/Float/abs|abs]]</code>===
===<code>[[Ruby/Float/abs|abs]]</code>===
يعيد التابع <code>abs</code> القيمة المطلقة للعدد العشري الذي استُدعي معه.
يعيد القيمة المطلقة للعدد العشري الذي استُدعي معه.


===<code>[[Ruby/Float/angle|angle]]</code>===
===<code>[[Ruby/Float/angle|angle]]</code>===
يعيد التابع <code>angle</code> القيمة <code>0</code> إن كان العدد العشري الذي استُدعي معه موجبًا، أو القيمة <code>[[Ruby/Math/PI|pi]]</code> خلاف ذلك.
يعيد القيمة <code>0</code> إن كان العدد العشري الذي استُدعي معه موجبًا، أو القيمة <code>[[Ruby/Math/PI|pi]]</code> خلاف ذلك.


===<code>[[Ruby/Float/arg|arg]]</code>===
===<code>[[Ruby/Float/arg|arg]]</code>===
يعيد التابع <code>arg</code> القيمة <code>0</code> إن كان العدد العشري الذي استُدعي معه موجبًا، أو القيمة <code>[[Ruby/Math/PI|pi]]</code> خلاف ذلك.
يعيد القيمة <code>0</code> إن كان العدد العشري الذي استُدعي معه موجبًا، أو القيمة <code>[[Ruby/Math/PI|pi]]</code> خلاف ذلك.


===<code>[[Ruby/Float/ceil|ceil]]</code>===
===<code>[[Ruby/Float/ceil|ceil]]</code>===
يعيد التابع <code>ceil</code> أصغر عدد من الأعداد الأكبر من أو تساوي العدد العشري الذي استُدعي معه وبدقة محدَّدة.
يعيد أصغر عدد من الأعداد الأكبر من أو تساوي العدد العشري الذي استُدعي معه وبدقة محدَّدة.


===<code>[[Ruby/Float/coerce|coerce]]</code>===
===<code>[[Ruby/Float/coerce|coerce]]</code>===
يحول التابع <code>coerce</code> العدد المستدعى معها والعدد العشري المُمرَّر إليها إلى النوع <code>[[Ruby/Float|Float]]</code> ويعيدهما في مصفوفة.
يحول العدد المستدعى معها والعدد العشري المُمرَّر إليها إلى النوع <code>[[Ruby/Float|Float]]</code> ويعيدهما في مصفوفة.


===<code>[[Ruby/Float/denominator|denominator]]</code>===
===<code>[[Ruby/Float/denominator|denominator]]</code>===
يعيد التابع <code>denominator</code> المقام (denominator) للعدد الكسري الذي استدعي معه، ويكون دائمًا موجبًا.
يعيد المقام (denominator) للعدد الكسري الذي استدعي معه، ويكون دائمًا موجبًا.


===<code>[[Ruby/Float/divmod|divmod]]</code>===
===<code>[[Ruby/Float/divmod|divmod]]</code>===
===<code>[[Ruby/Float/eql-3F|eql?]]</code>===
يعيد مصفوفة تحتوي على حاصل (quotient) وباقي قسمة العدد الذي استُدعي معه على العدد المُمرَّر إليه.
===<code>[[Ruby/Float/fdiv|fdiv]]</code>===
===<code>[[Ruby/Float/finite-3F|finite?]]</code>===
===<code>[[Ruby/Float/floor|floor]]</code>===
===<code>[[Ruby/Float/hash|hash]]</code>===
===<code>[[Ruby/Float/infinite-3F|infinite?]]</code>===
===<code>[[Ruby/Float/inspect|inspect]]</code>===
===<code>[[Ruby/Float/magnitude|magnitude]]</code>===
===<code>[[Ruby/Float/modulo|modulo]]</code>===
===<code>[[Ruby/Float/nan-3F|nan?]]</code>===
===<code>[[Ruby/Float/negative-3F|negative?]]</code>===
===<code>[[Ruby/Float/next_float|next_float]]</code>===
===<code>[[Ruby/Float/numerator|numerator]]</code>===
===<code>[[Ruby/Float/phase|phase]]</code>===
===<code>[[Ruby/Float/positive-3F|positive?]]</code>===
===<code>[[Ruby/Float/prev_float|prev_float]]</code>===
===<code>[[Ruby/Float/quo|quo]]</code>===
===<code>[[Ruby/Float/rationalize|rationalize]]</code>===
===<code>[[Ruby/Float/round|round]]</code>===
===<code>[[Ruby/Float/to_f|to_f]]</code>===
===<code>[[Ruby/Float/to_i|to_i]]</code>===
===<code>[[Ruby/Float/to_int|to_int]]</code>===
===<code>[[Ruby/Float/to_r|to_r]]</code>===
===<code>[[Ruby/Float/to_s|to_s]]</code>===
===<code>[[Ruby/Float/truncate|truncate]]</code>===
===<code>[[Ruby/Float/zero-3F|zero?]]</code>===
====<code>divmod(numeric) → array</code>====
راجع <code>Numeric#divmod</code>.<syntaxhighlight lang="ruby">
42.0.divmod(6)   #=> [7, 0.0]
42.0.divmod(5)  #=> [8, 2.0]
</syntaxhighlight>
====<code>eql?(obj) → true or false</code>====
إعادة <code>true</code> فقط إذا كانت <code>obj</code> من النوع Float وله نفس قيمة <code>float</code>. علي النقيض من ذلك مع <code>Float#==</code>‎، الذي يُجري تحويلات على النوع.<syntaxhighlight lang="ruby">
1.0.eql?(1)  #=> false


</syntaxhighlight>نتيجة NaN.eql?(NaN)‎ غير معرفة، لذا تُعاد قيمة تعتمد على التنفيذ.<syntaxhighlight lang="ruby">
===<code>[[Ruby/Float/eql-3F|eql?‎]]</code>===
يتحقق إن كان العدد الذي استُدعي معه والعدد المُمرَّر إليه من نفس النوع (أي كلاهما عدد عشري) ومتساويين في القيمة.


              VALUE
===<code>[[Ruby/Float/fdiv|fdiv]]</code>===
rb_float_eql(VALUE x, VALUE y)
يجري عملية القسمة بين العدد الذي استدعي معه والعدد الذي مُرِّر إليه ثم يعيد الناتج في عدد <nowiki/>[[Ruby/Float|عشري]].
{
    if (RB_TYPE_P(y, T_FLOAT)) {
        double a = RFLOAT_VALUE(x);
        double b = RFLOAT_VALUE(y);
#if defined(_MSC_VER) && _MSC_VER < 1300
        if (isnan(a) || isnan(b)) return Qfalse;
#endif
        if (a == b)
            return Qtrue;
    }
    return Qfalse;
}
</syntaxhighlight>
====<code>fdiv(numeric) → float</code>====
إعادة <code>float / numeric</code>، مثل <code>Float#/</code>‎.<syntaxhighlight lang="ruby">


              static VALUE
===<code>[[Ruby/Float/finite-3F|finite?‎]]</code>===
flo_quo(VALUE x, VALUE y)
يتحقق إذا كان العدد العشري الذي استدعي معه عددًا عشريًّا صالحًا وفقًا لمعيار IEEE؛ أي أنه ليس عددٌ لا نهائي ويعيد التابع ‎<code>nan?‎</code> القيمة <code>false</code> معه.
{
    return num_funcall1(x, '/', y);
}
           
</syntaxhighlight>
====<code>finite? → true or false</code>====
إعادة <code>true</code> إذا كان <code>float</code> عدد نقطة عائمة IEEE صالح، أي أنه ليس لا نهائي و ‎<code>#nan?‎</code> قيمتها <code>false</code>.<syntaxhighlight lang="ruby">


              VALUE
===<code>[[Ruby/Float/floor|floor]]</code>===
rb_flo_is_finite_p(VALUE num)
يعيد أكبر عدد من الأعداد الأصغر من أو تساوي العدد العشري الذي استُدعي معه وبدقة محدَّدة.
{
    double value = RFLOAT_VALUE(num);


#ifdef HAVE_ISFINITE
===<code>[[Ruby/Float/hash|hash]]</code>===
    if (!isfinite(value))
يعيد القيمة hash للعدد العشري الذي استدعي معه.
        return Qfalse;
#else
    if (isinf(value) || isnan(value))
        return Qfalse;
#endif


    return Qtrue;
===<code>[[Ruby/Float/infinite-3F|infinite?‎]]</code>===
}
يتحقق إذا ما إن كان العدد الذي استدعي معه منتهيًا (finite) أو غير منتهي من الطرف السالب (‎<code>-Infinity</code>) أو غير منتهي من الطرف الموجب (‎<code>+Infinity</code>).
         
</syntaxhighlight>
====<code>floor([ndigits]) → integer or float</code>====
إعادة أكبر رقم أصغر من أو يساوي <code>float</code> مع دقة <code>ndigits</code> رقم عشري (القيمة الافتراضية: 0).


عندما تكون الدقة سالبة، تكون القيمة المُعادة عدد صحيح متبوعًا بعدد أصفار مقداره <code>ndigits.abs</code> على الأقل.
===<code>[[Ruby/Float/inspect|inspect]]</code>===
هو اسم بديل للتابع <code>to_s</code>.


إعادة عدد عشري عندما يكون <code>ndigits</code> موجبًا، وإلا يُعاد عددٌ صحيحٌ.<syntaxhighlight lang="ruby">
===<code>[[Ruby/Float/magnitude|magnitude]]</code>===
1.2.floor      #=> 1
يعيد القيمة المطلقة للعدد العشري الذي استُدعي معه.
2.0.floor      #=> 2
(-1.2).floor  #=> -2
(-2.0).floor  #=> -2


1.234567.floor(2)  #=> 1.23
===<code>[[Ruby/Float/modulo|modulo]]</code>===
1.234567.floor(3)  #=> 1.234
يعيد باقي عملية قسمة العدد العشري الذي استُدعي معه على العدد المُعطى.
1.234567.floor(4)  #=> 1.2345
1.234567.floor(5)  #=> 1.23456


34567.89.floor(-5)  #=> 0
===<code>[[Ruby/Float/nan-3F|nan?‎]]</code>===
34567.89.floor(-4)  #=> 30000
يتحقق إذا كان العدد العشري الذي استدعي معه عددًا عشريًّا غير صالح وفقًا لمعيار IEEE.
34567.89.floor(-3)  #=> 34000
34567.89.floor(-2)  #=> 34500
34567.89.floor(-1)  #=> 34560
34567.89.floor(0)  #=> 34567
34567.89.floor(1)  #=> 34567.8
34567.89.floor(2)  #=> 34567.89
34567.89.floor(3)  #=> 34567.89
</syntaxhighlight>يُلاحظ أن الدقة المحدودة للنقطة العائمة الحسابية قد تؤدي إلى نتائج مُدهشة:<syntaxhighlight lang="ruby">
(0.3 / 0.1).floor  #=> 2 (!)


</syntaxhighlight>
===<code>[[Ruby/Float/negative-3F|negative?‎]]</code>===
====<code>hash → integer</code>====
يتحقق إن كان العدد العشري الذي استُدعي معه عددًا سالبًا.
إعادة رمز التجزئة لهذا الرقم العشري.


راجع أيضًا <code>Object#hash</code>.<syntaxhighlight lang="ruby">
===<code>[[Ruby/Float/next_float|next_float]]</code>===
يعيد العدد العشري الذي يلي العدد العشري الذي استُدعي معه.
              static VALUE
flo_hash(VALUE num)
{
    return rb_dbl_hash(RFLOAT_VALUE(num));
}
</syntaxhighlight>
====<code>infinite? → -1, 1, or nil</code>====
إعادة <code>nil</code> أو ‎-1، أو 1 اعتمادًا علي ما إذا كانت القيمة محدودة، أو ‎<code>-Infinity</code>، أو ‎<code>+Infinity</code>.<syntaxhighlight lang="ruby">
(0.0).infinite?        #=> nil
(-1.0/0.0).infinite?  #=> -1
(+1.0/0.0).infinite?  #=> 1
</syntaxhighlight>
====<code>inspect()‎</code>====
اسم المستعار للتابع <code>to_s</code>
====<code>magnitude → float</code>====
إعادة القيمة المطلقة للتابع <code>float</code>.<syntaxhighlight lang="ruby">
(-34.56).abs  #=> 34.56
-34.56.abs    #=> 34.56
34.56.abs      #=> 34.56
</syntaxhighlight><code>‎<nowiki>#</nowiki>magnitude</code> اسم مستعار للتابع ‎<code>#abs</code>.<syntaxhighlight lang="ruby">


              VALUE
===<code>[[Ruby/Float/numerator|numerator]]</code>===
rb_float_abs(VALUE flt)
يعيد البسط للعد الكسري الذي استدعي معه.
{
    double val = fabs(RFLOAT_VALUE(flt));
    return DBL2NUM(val);
}
</syntaxhighlight>
====<code>modulo(other) → float</code>====
إعادة الوحدة بعد قسمة <code>float</code> على <code>other</code>.<syntaxhighlight lang="ruby">
6543.21.modulo(137)      #=> 104.21000000000004
6543.21.modulo(137.24)  #=> 92.92999999999961
</syntaxhighlight><syntaxhighlight lang="ruby">
              static VALUE
flo_mod(VALUE x, VALUE y)
{
    double fy;


    if (RB_TYPE_P(y, T_FIXNUM)) {
===<code>[[Ruby/Float/phase|phase]]</code>===
        fy = (double)FIX2LONG(y);
يعيد القيمة <code>0</code> إن كان العدد العشري الذي استُدعي معه موجبًا، أو يعيد القيمة <code>[[Ruby/Math/PI|pi]]</code>خلاف ذلك.
    }
    else if (RB_TYPE_P(y, T_BIGNUM)) {
        fy = rb_big2dbl(y);
    }
    else if (RB_TYPE_P(y, T_FLOAT)) {
        fy = RFLOAT_VALUE(y);
    }
    else {
        return rb_num_coerce_bin(x, y, '%');
    }
    return DBL2NUM(ruby_float_mod(RFLOAT_VALUE(x), fy));
}
</syntaxhighlight>
====<code>nan? → true or false</code>====
إعادة <code>true</code> إذا كان <code>float</code> عدد نقطة عائمة IEEE غير صالح.<syntaxhighlight lang="ruby">
a = -1.0      #=> -1.0
a.nan?        #=> false
a = 0.0/0.0  #=> NaN
a.nan?        #=> true
</syntaxhighlight><syntaxhighlight lang="ruby">
              static VALUE
flo_is_nan_p(VALUE num)
{
    double value = RFLOAT_VALUE(num);


    return isnan(value) ? Qtrue : Qfalse;
===<code>[[Ruby/Float/positive-3F|positive?‎]]</code>===
}
يتحقق إن كان العدد العشري الذي استُدعي معه عددًا موجبًا.
           
</syntaxhighlight>
====<code>negative? → true or false</code>====
إعادة <code>true</code> إذا كان <code>float</code> أقل من 0.<syntaxhighlight lang="ruby">


              static VALUE
===<code>[[Ruby/Float/prev_float|prev_float]]</code>===
flo_negative_p(VALUE num)
يعيد العدد العشري الذي يسبق العدد العشري الذي استُدعي معه.
{
    double f = RFLOAT_VALUE(num);
    return f < 0.0 ? Qtrue : Qfalse;
}
     
</syntaxhighlight>
====<code>next_float → float</code>====
إعادة عدد النقطة العائمة القابل للتمثيل التالي.


<code>Float::MAX.next_float</code> و <code>Float::INFINITY.next_float</code> هما <code>Float::INFINITY</code>.
===<code>[[Ruby/Float/quo|quo]]</code>===
يعيد ناتج قسم العدد العشري المستدعى معه على العدد العشري المُمرَّر إليه.


<code>Float::NAN.next_float</code> هو <code>Float::NAN</code>.
===<code>[[Ruby/Float/rationalize|rationalize]]</code>===
يعيد قيمة تقريبة بسيطة (<code>flt-|eps| <= result <= flt+|eps|‎</code>) للعدد العشري الذي استدعي معه.


فعلى سبيل المثال:<syntaxhighlight lang="ruby">
===<code>[[Ruby/Float/round|round]]</code>===
0.01.next_float    #=> 0.010000000000000002
يقرِّب العدد الذي استُدعي معه إلى أقرب قيمة بدقة محدَّدة.
1.0.next_float    #=> 1.0000000000000002
100.0.next_float  #=> 100.00000000000001


0.01.next_float - 0.01    #=> 1.734723475976807e-18
===<code>[[Ruby/Float/to_f|to_f]]</code>===
1.0.next_float - 1.0      #=> 2.220446049250313e-16
يعيد العدد العشري الذي استدعي معه نفسه.
100.0.next_float - 100.0  #=> 1.4210854715202004e-14


f = 0.01; 20.times { printf "%-20a %s\n", f, f.to_s; f = f.next_float }
===<code>[[Ruby/Float/to_i|to_i]]</code>===
#=> 0x1.47ae147ae147bp-7 0.01
يحول العدد العشري الذي استُدعي معه إلى <nowiki/>[[Ruby/Integer|عدد صحيح]].
#  0x1.47ae147ae147cp-7 0.010000000000000002
#  0x1.47ae147ae147dp-7 0.010000000000000004
#  0x1.47ae147ae147ep-7 0.010000000000000005
#  0x1.47ae147ae147fp-7 0.010000000000000007
#  0x1.47ae147ae148p-7  0.010000000000000009
#  0x1.47ae147ae1481p-7 0.01000000000000001
#  0x1.47ae147ae1482p-7 0.010000000000000012
#  0x1.47ae147ae1483p-7 0.010000000000000014
#  0x1.47ae147ae1484p-7 0.010000000000000016
#  0x1.47ae147ae1485p-7 0.010000000000000018
#  0x1.47ae147ae1486p-7 0.01000000000000002
#  0x1.47ae147ae1487p-7 0.010000000000000021
#  0x1.47ae147ae1488p-7 0.010000000000000023
#  0x1.47ae147ae1489p-7 0.010000000000000024
#  0x1.47ae147ae148ap-7 0.010000000000000026
#  0x1.47ae147ae148bp-7 0.010000000000000028
#  0x1.47ae147ae148cp-7 0.01000000000000003
#  0x1.47ae147ae148dp-7 0.010000000000000031
#  0x1.47ae147ae148ep-7 0.010000000000000033


f = 0.0
===<code>[[Ruby/Float/to_int|to_int]]</code>===
100.times { f += 0.1 }
يحول العدد العشري الذي استُدعي معه إلى <nowiki/>[[Ruby/Integer|عدد صحيح]].
f                          #=> 9.99999999999998      # should be 10.0 in the ideal world.
10-f                        #=> 1.9539925233402755e-14 # the floating point error.
10.0.next_float-10          #=> 1.7763568394002505e-15 # 1 ulp (unit in the last place).
(10-f)/(10.0.next_float-10) #=> 11.0                  # the error is 11 ulp.
(10-f)/(10*Float::EPSILON)  #=> 8.8                    # approximation of the above.
"%a" % 10                  #=> "0x1.4p+3"
"%a" % f                    #=> "0x1.3fffffffffff5p+3" # the last hex digit is 5.  16 - 5 = 11 ulp.
</syntaxhighlight>
====<code>numerator → integer</code>====
إعادة البسط. والنتيجة تعتمد على الآلة.<syntaxhighlight lang="ruby">
n = 0.3.numerator    #=> 5404319552844595
d = 0.3.denominator  #=> 18014398509481984
n.fdiv(d)            #=> 0.3


</syntaxhighlight>انظر أيضا <code>‎#denominator</code>.<syntaxhighlight lang="ruby">
===<code>[[Ruby/Float/to_r|to_r]]</code>===
يحول العدد العشري الذي استُدعي معه إلى <nowiki/>[[Ruby/Rational|عدد جذري]] (rational).


              static VALUE
===<code>[[Ruby/Float/to_s|to_s]]</code>===
float_numerator(VALUE self)
يحول العدد العشري الذي استدعي معه إلى سلسلة نصية.
{
    double d = RFLOAT_VALUE(self);
    VALUE r;
    if (isinf(d) || isnan(d))
        return self;
    r = float_to_r(self);
    if (canonicalization && k_integer_p(r)) {
        return r;
    }
    return nurat_numerator(r);
}
</syntaxhighlight>
====<code>phase → 0 or float</code>====
إعادة 0 إذا كانت القيمة موجبة، أو "ط (pi)" خلاف ذلك.<syntaxhighlight lang="ruby">
              static VALUE
float_arg(VALUE self)
{
    if (isnan(RFLOAT_VALUE(self)))
        return self;
    if (f_tpositive_p(self))
        return INT2FIX(0);
    return rb_const_get(rb_mMath, id_PI);
}
</syntaxhighlight>
====<code>positive? → true or false</code>====
إعادة <code>true</code> إذا كان <code>float</code> أكبر من 0.<syntaxhighlight lang="ruby">
              static VALUE
flo_positive_p(VALUE num)
{
    double f = RFLOAT_VALUE(num);
    return f > 0.0 ? Qtrue : Qfalse;
}
           
</syntaxhighlight>
====<code>prev_float → float</code>====
إعادة عدد النقطة العائمة القابل للتمثيل السابق.


‎<code>(-Float::MAX).prev_float</code> و <code>‎(-Float::INFINITY).prev_float</code> هما ‎<code>-Float::INFINITY</code>.
===<code>[[Ruby/Float/truncate|truncate]]</code>===
 
يعيد العدد العشري الذي استُدعي معه بعد اقتطاعه إلى دقة (precision) محدَّدة.
<code>Float::NAN.prev_float</code> هو <code>Float::NAN</code>.
 
فعلى سبيل المثال:<syntaxhighlight lang="ruby">
0.01.prev_float    #=> 0.009999999999999998
1.0.prev_float    #=> 0.9999999999999999
100.0.prev_float  #=> 99.99999999999999
 
0.01 - 0.01.prev_float    #=> 1.734723475976807e-18
1.0 - 1.0.prev_float      #=> 1.1102230246251565e-16
100.0 - 100.0.prev_float  #=> 1.4210854715202004e-14
 
f = 0.01; 20.times { printf "%-20a %s\n", f, f.to_s; f = f.prev_float }
#=> 0x1.47ae147ae147bp-7 0.01
#  0x1.47ae147ae147ap-7 0.009999999999999998
#  0x1.47ae147ae1479p-7 0.009999999999999997
#  0x1.47ae147ae1478p-7 0.009999999999999995
#  0x1.47ae147ae1477p-7 0.009999999999999993
#  0x1.47ae147ae1476p-7 0.009999999999999992
#  0x1.47ae147ae1475p-7 0.00999999999999999
#  0x1.47ae147ae1474p-7 0.009999999999999988
#  0x1.47ae147ae1473p-7 0.009999999999999986
#  0x1.47ae147ae1472p-7 0.009999999999999985
#  0x1.47ae147ae1471p-7 0.009999999999999983
#  0x1.47ae147ae147p-7  0.009999999999999981
#  0x1.47ae147ae146fp-7 0.00999999999999998
#  0x1.47ae147ae146ep-7 0.009999999999999978
#  0x1.47ae147ae146dp-7 0.009999999999999976
#  0x1.47ae147ae146cp-7 0.009999999999999974
#  0x1.47ae147ae146bp-7 0.009999999999999972
#  0x1.47ae147ae146ap-7 0.00999999999999997
#  0x1.47ae147ae1469p-7 0.009999999999999969
#  0x1.47ae147ae1468p-7 0.009999999999999967
</syntaxhighlight>
====<code>quo(numeric) → float</code>====
إعادة <code>float / numeric</code>، مثل <code>Float#/</code>‎.<syntaxhighlight lang="ruby">
 
              static VALUE
flo_quo(VALUE x, VALUE y)
{
    return num_funcall1(x, '/', y);
}
           
</syntaxhighlight>
====<code>rationalize([eps]) → rational</code>====
إعادة تقريب ابسط للقيمة <code>(flt-|eps| <= result <= flt+|eps|)</code>. إذا لم يتاح الوسيط الاختياري <code>eps</code>، سيُختار تلقائيًا.<syntaxhighlight lang="ruby">
0.3.rationalize          #=> (3/10)
1.333.rationalize        #=> (1333/1000)
1.333.rationalize(0.01)  #=> (4/3)
</syntaxhighlight>انظر أيضا ‎<code>#to_r</code>.<syntaxhighlight lang="ruby">
 
              static VALUE
float_rationalize(int argc, VALUE *argv, VALUE self)
{
    VALUE e;
    double d = RFLOAT_VALUE(self);
 
    if (d < 0.0)
        return rb_rational_uminus(float_rationalize(argc, argv, DBL2NUM(-d)));
 
    rb_scan_args(argc, argv, "01", &e);
 
    if (argc != 0) {
        return rb_flt_rationalize_with_prec(self, e);
    }
    else {
        return rb_flt_rationalize(self);
    }
}
       
</syntaxhighlight><code>round([ndigits] [, half: mode]) → integer or float</code>
 
إعادة <code>float</code> مُقرَّب إلى أقرب قيمة بدقة أرقام عشرية مقدارها <code>ndigits</code> (القيمة الافتراضية: 0).
 
عندما تكون الدقة سالبة، تكون القيمة المُعادة عدد صحيح متبوعًا بعدد أصفار مقداره <code>ndigits.abs</code> على الأقل.
 
إعادة عدد عشري عندما يكون <code>ndigits</code> موجبًا، وإلا يُعاد عددٌا صحيحٌا.<syntaxhighlight lang="ruby">
1.4.round      #=> 1
1.5.round      #=> 2
1.6.round      #=> 2
(-1.5).round  #=> -2
 
1.234567.round(2)  #=> 1.23
1.234567.round(3)  #=> 1.235
1.234567.round(4)  #=> 1.2346
1.234567.round(5)  #=> 1.23457
 
34567.89.round(-5)  #=> 0
34567.89.round(-4)  #=> 30000
34567.89.round(-3)  #=> 35000
34567.89.round(-2)  #=> 34600
34567.89.round(-1)  #=> 34570
34567.89.round(0)  #=> 34568
34567.89.round(1)  #=> 34567.9
34567.89.round(2)  #=> 34567.89
34567.89.round(3)  #=> 34567.89
</syntaxhighlight>إذا أُتيح وسيط الكلمة المفتاحية half الاختياري، ستُقرَّب الأرقام التي تقع في المنتصف بين قيمتين مقرَّبتين ممكنتين وفقًا للوضع mode المُحدَّد الكاسر للعلاقة:
* ‎:up أو nil: تقريب النصف بعيدًا عن الصفر (الوضع الافتراضي).
* ‎:down: تقريب النصف باتجاه الصفر.
* ‎:even: تقريب النصف باتجاه أقرب عدد زوجي.
<syntaxhighlight lang="ruby">
2.5.round(half: :up)      #=> 3
2.5.round(half: :down)    #=> 2
2.5.round(half: :even)    #=> 2
3.5.round(half: :up)      #=> 4
3.5.round(half: :down)    #=> 3
3.5.round(half: :even)    #=> 4
(-2.5).round(half: :up)  #=> -3
(-2.5).round(half: :down) #=> -2
(-2.5).round(half: :even) #=> -2
</syntaxhighlight>
 
==== <code>to_f → self</code> ====
بما أن <code>float</code> هو بالأصل Float، يُعيد <code>self</code>.<syntaxhighlight lang="ruby">
 
              static VALUE
flo_to_f(VALUE num)
{
    return num;
}
           
</syntaxhighlight>
 
==== <code>to_i → integer</code> ====
إعادة <code>float</code> مبتورًا إلى <code>Integer</code>.<syntaxhighlight lang="ruby">
1.2.to_i      #=> 1
(-1.2).to_i  #=> -1
</syntaxhighlight>يُلاحظ أن الدقة المحدودة للنقطة العائمة الحسابية قد تؤدي إلى نتائج مُدهشة:<syntaxhighlight lang="ruby">
(0.3 / 0.1).to_i  #=> 2 (!)
 
</syntaxhighlight><code>to_int</code> هو اسم مستعار للتابع <code>to_i</code>.<syntaxhighlight lang="ruby">
 
              static VALUE
flo_to_i(VALUE num)
{
    double f = RFLOAT_VALUE(num);
 
    if (f > 0.0) f = floor(f);
    if (f < 0.0) f = ceil(f);
 
    return dbl2ival(f);
}
         
</syntaxhighlight>
 
==== <code>to_int → integer</code> ====
إعادة <code>float</code> مبتورًا إلى <code>Integer</code>.<syntaxhighlight lang="ruby">
1.2.to_i      #=> 1
(-1.2).to_i  #=> -1
</syntaxhighlight>يُلاحظ أن الدقة المحدودة للنقطة العائمة الحسابية قد تؤدي إلى نتائج مُدهشة:<syntaxhighlight lang="ruby">
(0.3 / 0.1).to_i  #=> 2 (!)
 
</syntaxhighlight><code>to_int</code> هو اسم مستعار للتابع <code>to_i</code>.<syntaxhighlight lang="ruby">
 
              static VALUE
flo_to_i(VALUE num)
{
    double f = RFLOAT_VALUE(num);
 
    if (f > 0.0) f = floor(f);
    if (f < 0.0) f = ceil(f);
 
    return dbl2ival(f);
}
         
</syntaxhighlight>
 
==== <code>to_r → rational</code> ====
إعادة قيمة نسبية.<syntaxhighlight lang="ruby">
2.0.to_r    #=> (2/1)
2.5.to_r    #=> (5/2)
-0.75.to_r  #=> (-3/4)
0.0.to_r    #=> (0/1)
0.3.to_r    #=> (5404319552844595/18014398509481984)
</syntaxhighlight>ملاحظة: ‎<code>0.3.to_r</code> ليس هي نفسه <code>‎“0.3”.to_r</code>. وهذا الأخير يعادل ‎<code>"3/10".to_r</code>، ولكن الأول ليس كذلك.<syntaxhighlight lang="ruby">
0.3.to_r  == 3/10r  #=> false
"0.3".to_r == 3/10r  #=> true
</syntaxhighlight>انظر أيضا ‎<code>#rationalize</code>.<syntaxhighlight lang="ruby">
              static VALUE
float_to_r(VALUE self)
{
    VALUE f, n;
 
    float_decode_internal(self, &f, &n);
#if FLT_RADIX == 2
    {
        long ln = FIX2LONG(n);
 
        if (ln == 0)
            return rb_rational_new1(f);
        if (ln > 0)
            return rb_rational_new1(rb_int_lshift(f, n));
        ln = -ln;
        return rb_rational_new2(f, rb_int_lshift(ONE, INT2FIX(ln)));
    }
#else
    f = rb_int_mul(f, rb_int_pow(INT2FIX(FLT_RADIX), n));
    if (RB_TYPE_P(f, T_RATIONAL))
        return f;
    return rb_rational_new1(f);
#endif
}
</syntaxhighlight>
====<code>to_s → string</code>====
إعادة سلسلة تحتوي على تمثيل <code>self</code>. كما هو حال الشكل الثابت أو الأسي للتابع <code>float</code>، قد يُعيد الاستدعاء <code>NaN</code> و <code>Infinity</code> و <code>‎-Infinity</code>.<syntaxhighlight lang="ruby">
              static VALUE
flo_to_s(VALUE flt)
{
    enum {decimal_mant = DBL_MANT_DIG-DBL_DIG};
    enum {float_dig = DBL_DIG+1};
    char buf[float_dig + (decimal_mant + CHAR_BIT - 1) / CHAR_BIT + 10];
    double value = RFLOAT_VALUE(flt);
    VALUE s;
    char *p, *e;
    int sign, decpt, digs;
 
    if (isinf(value)) {
        static const char minf[] = "-Infinity";
        const int pos = (value > 0); /* skip "-" */
        return rb_usascii_str_new(minf+pos, strlen(minf)-pos);
    }
    else if (isnan(value))
        return rb_usascii_str_new2("NaN");
 
    p = ruby_dtoa(value, 0, 0, &decpt, &sign, &e);
    s = sign ? rb_usascii_str_new_cstr("-") : rb_usascii_str_new(0, 0);
    if ((digs = (int)(e - p)) >= (int)sizeof(buf)) digs = (int)sizeof(buf) - 1;
    memcpy(buf, p, digs);
    xfree(p);
    if (decpt > 0) {
        if (decpt < digs) {
            memmove(buf + decpt + 1, buf + decpt, digs - decpt);
            buf[decpt] = '.';
            rb_str_cat(s, buf, digs + 1);
        }
        else if (decpt <= DBL_DIG) {
            long len;
            char *ptr;
            rb_str_cat(s, buf, digs);
            rb_str_resize(s, (len = RSTRING_LEN(s)) + decpt - digs + 2);
            ptr = RSTRING_PTR(s) + len;
            if (decpt > digs) {
                memset(ptr, '0', decpt - digs);
                ptr += decpt - digs;
            }
            memcpy(ptr, ".0", 2);
        }
        else {
            goto exp;
        }
    }
    else if (decpt > -4) {
        long len;
        char *ptr;
        rb_str_cat(s, "0.", 2);
        rb_str_resize(s, (len = RSTRING_LEN(s)) - decpt + digs);
        ptr = RSTRING_PTR(s);
        memset(ptr += len, '0', -decpt);
        memcpy(ptr -= decpt, buf, digs);
    }
    else {
      exp:
        if (digs > 1) {
            memmove(buf + 2, buf + 1, digs - 1);
        }
        else {
            buf[2] = '0';
            digs++;
        }
        buf[1] = '.';
        rb_str_cat(s, buf, digs + 1);
        rb_str_catf(s, "e%+03d", decpt - 1);
    }
    return s;
}
       
</syntaxhighlight>ويُعيَّن له أيضًا الاسم المستعار: <code>inspect</code>.
 
====<code>truncate([ndigits]) → integer or float</code>====
إعادة <code>float</code> مبتورًا (نحو الصفر) إلى دقة أرقام عشرية <code>ndigits</code> (القيمة الافتراضية: 0).
 
عندما تكون الدقة سالبة، تكون القيمة المُعادة عدد صحيح متبوعًا بعدد أصفار مقداره <code>ndigits.abs</code> على الأقل.
 
إعادة عدد عشري عندما يكون <code>ndigits</code> موجبًا، وإلا يُعاد عددٌ صحيحٌ.<syntaxhighlight lang="ruby">
2.8.truncate          #=> 2
(-2.8).truncate        #=> -2
1.234567.truncate(2)  #=> 1.23
34567.89.truncate(-2)  #=> 34500
</syntaxhighlight>يُلاحظ أن الدقة المحدودة للنقطة العائمة الحسابية قد تؤدي إلى نتائج مُدهشة:<syntaxhighlight lang="ruby">
(0.3 / 0.1).truncate  #=> 2 (!)


</syntaxhighlight>
===<code>[[Ruby/Float/zero-3F|zero?‎]]</code>===
====<code>zero? → true or false</code>====
يتحقق إن كانت قيمة العدد العشري الذي استُدعي معه تساوي الصفر.
إعادة <code>true</code> إذا كان <code>float</code> يساوي 0.<syntaxhighlight lang="ruby">


              static VALUE
== مصادر ==
flo_zero_p(VALUE num)
{
    if (RFLOAT_VALUE(num) == 0.0) {
        return Qtrue;
    }
    return Qfalse;
}
</syntaxhighlight>
=مصادر=
* <span> </span>[http://ruby-doc.org/core-2.5.1/Float.html صفحة الصنف Float في توثيق روبي الرسمي.]
* <span> </span>[http://ruby-doc.org/core-2.5.1/Float.html صفحة الصنف Float في توثيق روبي الرسمي.]
[[تصنيف:Ruby]]
[[تصنيف:Ruby]]
[[تصنيف:Ruby Class]]
[[تصنيف:Ruby Class]]
[[تصنيف:Ruby Float]]
[[تصنيف:Ruby Float]]

المراجعة الحالية بتاريخ 11:19، 24 نوفمبر 2018

تمثِّل كائنات الصنف Float أعدادًا حقيقيةً غير دقيقة (inexact real numbers) باستخدام التمثيل العشري ذي الدقة المضاعفة للبنية الأصلية.

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

الثوابت

DIG

الحد الأدنى لعدد الأرقام العشرية ذات الدلالة في المنازل العشرية المزدوجة الدقة. وعادةً ما تكون قيمته الافتراضية 15.

EPSILON

الفرق بين 1 و أصغر عدد عشري ذي دقة مضاعفة أكبر من 1 من نوع النقطة العائمة المزدوجة الدقة. وعادة ما تكون قيمته الافتراضية هي 2.2204460492503131e-16.

INFINITY

يمثل اللانهاية الموجبة.

MANT_DIG

عدد الأرقام الأساسية للأعداد العشرية المضاعفة (أي البيانات ذات النوع double). وعادةً ما تكون قيمته الافتراضية هي 53.

MAX

أكبر عدد صحيح في العدد العشري ذي الدقة المضاعفة. وعادةً ما تكون قيمته الافتراضية 1.7976931348623157e+308.

MAX_10_EXP

أكبر أس موجب في العدد العشري ذي الدقة المضاعفة حيث تكون القيمة 10 مرفوعة إلى هذا الأس بعد طرح القيمة 1 منها. وعادةً ما تكون قيمته الافتراضية هي 308.

MAX_EXP

أكبر قيمة أس محتملة في العدد العشري ذي الدقة المضاعفة. وعادةً ما تكون قيمته الافتراضية هي 1024.

MIN

أصغر رقم طبيعي (normalized number) موجب في العدد العشري ذي الدقة المضاعفة. وعادة ما تكون قيمته الافتراضية 2.2250738585072014e-308.

إذا كانت المنصة تدعم الأعداد غير الطبيعية (denormalized numbers)، فسيكون هناك أرقام بين الصفر والقيمة Float::MIN. وتعيد ‎0.0.next_float أصغر عدد عشري موجب بما في ذلك الأعداد غير الطبيعية (denormalized numbers).

MIN_10_EXP

أصغر أس سالب في العدد العشري ذي الدقة المضاعفة إذ تكون 10 مرفوعة إلى هذا الأس ناقص 1. وعادةً ما تكون قيمته الافتراضية ‎-307.

MIN_EXP

أصغر قيمة أس محتملة في العدد العشري ذي الدقة المضاعفة. وعادةً ما تكون قيمته الافتراضية ‎-1021.

NAN

تعبير يمثل القيمة "ليست عددًا" (not a number).

RADIX

أساس العدد العشري، أو عدد الأرقام الفريدة المستخدمة لتمثيل العدد. وعادةً ما تكون قيمته الافتراضية 2 على معظم الأنظمة، والتي تمثل النظام العشري ذي الأساس 10.

ROUNDS

يمثل وضع التقريب لإضافة المنازل العشرية. وعادةً ما تكون قيمته الافتراضية 1، التقريب إلى أقرب عدد.

وتشمل الأوضاع الأخرى:

  • ‎-1: مُتعذِّر تحديده.
  • 0: التقريب نحو الصفر.
  • 1: التقريب إلى أقرب عدد.
  • 2: التقريب نحو اللانهاية الموجبة.
  • 3: التقريب نحو اللانهاية السالبة.

توابع النسخة العامة

%

يعيد باقي عملية قسمة عدد عشري على عدد آخر.

*

يعيد ناتج عملية ضرب عدد عشري بعدد آخر.

**

يعيد ناتج عملية رفع عدد عشري (الأساس) إلى قوة عدد محدد (الأس).

+

يعيد ناتج عملية الجمع بين عددين.

-

يعيد ناتج عملية الطرح بين عددين.

-

إن استُعمِل هذا المعامل بالشكل ‎-Float، فسيعيد القيمة المعاكسة للعدد Float العشري (أي القيمة السالبة إن كان Float موجبًا أو العكس بالعكس).

/

يعيد ناتج عملية القسمة بين عدد عشري وعدد آخر.

>

يعيد القيمة true إن كانت قيمة العدد العشري الواقع على يساره أصغر من قيمة العدد المواقع على يمينه.

=>

يعيد القيمة true إن كانت قيمة العدد العشري الواقع على يساره أصغر من أو تساوي قيمة العدد الواقع على يمينه.

<=>

يعيد عددً‎ا صحيحًا (‎-1 أو 0 أو ‎+1) إذا كان العدد العشري الواقع على يساره أصغر من أو يساوي أو أكبر من العدد الآخر الواقع على يمينه على التوالي.

==

يعيد القيمة true إن كان العدد العشري الواقع على يساره يساوي القيمة الواقعة على يمينه. 

<

يعيد القيمة true إن كانت قيمة العدد العشري الواقع على يساره أكبر من قيمة العدد الآخر الواقع على يمينه.

=<

يعيد القيمة true إن كانت قيمة العدد العشري الواقع على يساره أكبر من أو تساوي قيمة العدد الآخر الواقع على يمينه.

abs

يعيد القيمة المطلقة للعدد العشري الذي استُدعي معه.

angle

يعيد القيمة 0 إن كان العدد العشري الذي استُدعي معه موجبًا، أو القيمة pi خلاف ذلك.

arg

يعيد القيمة 0 إن كان العدد العشري الذي استُدعي معه موجبًا، أو القيمة pi خلاف ذلك.

ceil

يعيد أصغر عدد من الأعداد الأكبر من أو تساوي العدد العشري الذي استُدعي معه وبدقة محدَّدة.

coerce

يحول العدد المستدعى معها والعدد العشري المُمرَّر إليها إلى النوع Float ويعيدهما في مصفوفة.

denominator

يعيد المقام (denominator) للعدد الكسري الذي استدعي معه، ويكون دائمًا موجبًا.

divmod

يعيد مصفوفة تحتوي على حاصل (quotient) وباقي قسمة العدد الذي استُدعي معه على العدد المُمرَّر إليه.

eql?‎

يتحقق إن كان العدد الذي استُدعي معه والعدد المُمرَّر إليه من نفس النوع (أي كلاهما عدد عشري) ومتساويين في القيمة.

fdiv

يجري عملية القسمة بين العدد الذي استدعي معه والعدد الذي مُرِّر إليه ثم يعيد الناتج في عدد عشري.

finite?‎

يتحقق إذا كان العدد العشري الذي استدعي معه عددًا عشريًّا صالحًا وفقًا لمعيار IEEE؛ أي أنه ليس عددٌ لا نهائي ويعيد التابع ‎nan?‎ القيمة false معه.

floor

يعيد أكبر عدد من الأعداد الأصغر من أو تساوي العدد العشري الذي استُدعي معه وبدقة محدَّدة.

hash

يعيد القيمة hash للعدد العشري الذي استدعي معه.

infinite?‎

يتحقق إذا ما إن كان العدد الذي استدعي معه منتهيًا (finite) أو غير منتهي من الطرف السالب (‎-Infinity) أو غير منتهي من الطرف الموجب (‎+Infinity).

inspect

هو اسم بديل للتابع to_s.

magnitude

يعيد القيمة المطلقة للعدد العشري الذي استُدعي معه.

modulo

يعيد باقي عملية قسمة العدد العشري الذي استُدعي معه على العدد المُعطى.

nan?‎

يتحقق إذا كان العدد العشري الذي استدعي معه عددًا عشريًّا غير صالح وفقًا لمعيار IEEE.

negative?‎

يتحقق إن كان العدد العشري الذي استُدعي معه عددًا سالبًا.

next_float

يعيد العدد العشري الذي يلي العدد العشري الذي استُدعي معه.

numerator

يعيد البسط للعد الكسري الذي استدعي معه.

phase

يعيد القيمة 0 إن كان العدد العشري الذي استُدعي معه موجبًا، أو يعيد القيمة piخلاف ذلك.

positive?‎

يتحقق إن كان العدد العشري الذي استُدعي معه عددًا موجبًا.

prev_float

يعيد العدد العشري الذي يسبق العدد العشري الذي استُدعي معه.

quo

يعيد ناتج قسم العدد العشري المستدعى معه على العدد العشري المُمرَّر إليه.

rationalize

يعيد قيمة تقريبة بسيطة (flt-|eps| <= result <= flt+|eps|‎) للعدد العشري الذي استدعي معه.

round

يقرِّب العدد الذي استُدعي معه إلى أقرب قيمة بدقة محدَّدة.

to_f

يعيد العدد العشري الذي استدعي معه نفسه.

to_i

يحول العدد العشري الذي استُدعي معه إلى عدد صحيح.

to_int

يحول العدد العشري الذي استُدعي معه إلى عدد صحيح.

to_r

يحول العدد العشري الذي استُدعي معه إلى عدد جذري (rational).

to_s

يحول العدد العشري الذي استدعي معه إلى سلسلة نصية.

truncate

يعيد العدد العشري الذي استُدعي معه بعد اقتطاعه إلى دقة (precision) محدَّدة.

zero?‎

يتحقق إن كانت قيمة العدد العشري الذي استُدعي معه تساوي الصفر.

مصادر

مجلوبة من «https://wiki.hsoub.com/index.php?title=Ruby/Float&oldid=24473»