|
|
| (1 مراجعات متوسطة بواسطة نفس المستخدم غير معروضة) |
| سطر 1: |
سطر 1: |
| <noinclude>{{DISPLAYTITLE: الأعداد العشرية Float في روبي}}</noinclude> | | <noinclude>{{DISPLAYTITLE: الصنف <code>Float</code> في روبي}}</noinclude> |
| | تمثِّل كائنات الصنف <code>Float</code> أعدادًا حقيقيةً غير دقيقة (inexact real numbers) باستخدام التمثيل العشري ذي الدقة المضاعفة للبنية الأصلية. |
|
| |
|
| تمثل كائنات Float أرقامًا حقيقية غير دقيقة باستخدام تمثيل النقطة العائمة المزدوجة الدقة للبنية الأصلية.
| | للمنازل العشرية حساب مختلف وهو عدد غير دقيق، لذا يجب معرفة نظامها الخاص. نقترخ عليك الاطلاع على الصفحات التالية: |
|
| |
|
| للنقطة العائمة حساب مختلف وهو رقم غير دقيق. لذا يجب معرفة نظامها الخاص. انظر التالي:
| | * [https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html ما هي الأشياء التي يجب أن يعرفها كل عالم حاسوب عن الأعداد العشرية]. |
|
| |
|
| [[docs.sun.com/source/806-3568/ncg_goldberg.html]] | | * [https://github.com/rdp/ruby_tutorials_core/wiki/ruby-talk-faq#floats_imprecise لماذا الأعداد العشرية في روبي غير دقيقة؟] |
|
| |
|
| [[wiki.github.com/rdp/ruby_tutorials_core/ruby-talk-faq#wiki-floats_imprecise]] | | * [[wikipedia:Floating-point_arithmetic#Accuracy_problems|مشاكل في الدقة]]. |
| | ==الثوابت== |
| | ===<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>. |
|
| |
|
| [[en.wikipedia.org/wiki/Floating_point#Accuracy_problems]] | | إذا كانت المنصة تدعم الأعداد غير الطبيعية ([[wikipedia:Denormal_number|denormalized numbers]])، فسيكون هناك أرقام بين الصفر والقيمة <code>Float::MIN</code>. وتعيد <code>0.0.next_float</code> أصغر عدد عشري موجب بما في ذلك الأعداد غير الطبيعية ([[wikipedia:Denormal_number|denormalized numbers]]). |
| ===الثوابت===
| | ===<code>MIN_10_EXP</code>=== |
| ====<code>DIG</code>====
| | أصغر أس سالب في العدد العشري ذي الدقة المضاعفة إذ تكون <code>10</code> مرفوعة إلى هذا الأس ناقص <code>1</code>. وعادةً ما تكون قيمته الافتراضية <code>-307</code>. |
| الحد الأدنى لعدد الأرقام العشرية ذات الدلالة في النقطة العائمة المزدوجة الدقة.
| | ===<code>MIN_EXP</code>=== |
| | | أصغر قيمة أس محتملة في العدد العشري ذي الدقة المضاعفة. وعادةً ما تكون قيمته الافتراضية <code>-1021</code>. |
| وعادة ما تكون قيمته الافتراضية <code>15</code>.
| | ===<code>NAN</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>====
| |
| أصغر رقم مُعيَّر موجب في النقطة العائمة المزدوجة الدقة.
| |
| | |
| وعادة ما تكون قيمته الافتراضية <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>2</code> : التقريب نحو اللانهاية الموجبة.
| |
| | |
| <code>3</code> : التقريب نحو اللانهاية السالبة.
| |
| ===توابع المثيل العام===
| |
| ====<code>float % 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)) {
| |
| fy = (double)FIX2LONG(y);
| |
| }
| |
| 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>float * other → float</code>====
| |
| إعادة Float جديد والذي يكون هو نتاج حاصل ضرب <code>float</code> و <code>other</code>.<syntaxhighlight lang="ruby">
| |
|
| |
| static VALUE
| |
| flo_mul(VALUE x, VALUE y)
| |
| {
| |
| if (RB_TYPE_P(y, T_FIXNUM)) {
| |
| return DBL2NUM(RFLOAT_VALUE(x) * (double)FIX2LONG(y));
| |
| }
| |
| else if (RB_TYPE_P(y, T_BIGNUM)) {
| |
| return DBL2NUM(RFLOAT_VALUE(x) * rb_big2dbl(y));
| |
| }
| |
| else if (RB_TYPE_P(y, T_FLOAT)) {
| |
| return DBL2NUM(RFLOAT_VALUE(x) * RFLOAT_VALUE(y));
| |
| }
| |
| else {
| |
| return rb_num_coerce_bin(x, y, '*');
| |
| }
| |
| }
| |
| </syntaxhighlight>
| |
| ====<code>float ** other → float</code>====
| |
| رفع <code>float</code> للأس <code>other</code>.<syntaxhighlight lang="ruby">
| |
| 2.0**3 #=> 8.0
| |
| | |
| </syntaxhighlight><syntaxhighlight lang="ruby">
| |
|
| |
| VALUE
| |
| rb_float_pow(VALUE x, VALUE y)
| |
| {
| |
| double dx, dy;
| |
| if (RB_TYPE_P(y, T_FIXNUM)) {
| |
| dx = RFLOAT_VALUE(x);
| |
| dy = (double)FIX2LONG(y);
| |
| }
| |
| else if (RB_TYPE_P(y, T_BIGNUM)) {
| |
| dx = RFLOAT_VALUE(x);
| |
| dy = rb_big2dbl(y);
| |
| }
| |
| else if (RB_TYPE_P(y, T_FLOAT)) {
| |
| dx = RFLOAT_VALUE(x);
| |
| dy = RFLOAT_VALUE(y);
| |
| if (dx < 0 && dy != round(dy))
| |
| return num_funcall1(rb_complex_raw1(x), idPow, y);
| |
| }
| |
| else {
| |
| return rb_num_coerce_bin(x, y, idPow);
| |
| }
| |
| return DBL2NUM(pow(dx, dy));
| |
| }
| |
|
| |
| </syntaxhighlight>
| |
| ====<code>float + other → float</code>====
| |
| إعادة Float جديد والذي يكون هو نتاج حاصل جمع <code>float</code> و <code>other</code>.<syntaxhighlight lang="ruby">
| |
|
| |
| static VALUE
| |
| flo_plus(VALUE x, VALUE y)
| |
| {
| |
| if (RB_TYPE_P(y, T_FIXNUM)) {
| |
| return DBL2NUM(RFLOAT_VALUE(x) + (double)FIX2LONG(y));
| |
| }
| |
| else if (RB_TYPE_P(y, T_BIGNUM)) {
| |
| return DBL2NUM(RFLOAT_VALUE(x) + rb_big2dbl(y));
| |
| }
| |
| else if (RB_TYPE_P(y, T_FLOAT)) {
| |
| return DBL2NUM(RFLOAT_VALUE(x) + RFLOAT_VALUE(y));
| |
| }
| |
| else {
| |
| return rb_num_coerce_bin(x, y, '+');
| |
| }
| |
| }
| |
| </syntaxhighlight>
| |
| ====<code>float - other → float</code>====
| |
| إعادة Float جديد والذي يكون هو الفرق بين <code>float</code> و <code>other</code>.<syntaxhighlight lang="ruby">
| |
| | |
| static VALUE
| |
| flo_minus(VALUE x, VALUE y)
| |
| {
| |
| if (RB_TYPE_P(y, T_FIXNUM)) {
| |
| return DBL2NUM(RFLOAT_VALUE(x) - (double)FIX2LONG(y));
| |
| }
| |
| else if (RB_TYPE_P(y, T_BIGNUM)) {
| |
| return DBL2NUM(RFLOAT_VALUE(x) - rb_big2dbl(y));
| |
| }
| |
| else if (RB_TYPE_P(y, T_FLOAT)) {
| |
| return DBL2NUM(RFLOAT_VALUE(x) - RFLOAT_VALUE(y));
| |
| }
| |
| else {
| |
| return rb_num_coerce_bin(x, y, '-');
| |
| }
| |
| }
| |
|
| |
| </syntaxhighlight>
| |
| ====<code>-float → float</code>====
| |
| إعادة <code>float</code> بعلامة سالبة.<syntaxhighlight lang="ruby">
| |
|
| |
| VALUE
| |
| rb_float_uminus(VALUE flt)
| |
| {
| |
| return DBL2NUM(-RFLOAT_VALUE(flt));
| |
| }
| |
|
| |
| </syntaxhighlight>
| |
| ====<code>float / other → float</code>====
| |
| إعادة Float جديد والذي يكون نتاج حاصل قسمة <code>float</code> على <code>other</code>.<syntaxhighlight lang="ruby">
| |
|
| |
| static VALUE
| |
| flo_div(VALUE x, VALUE y)
| |
| {
| |
| long f_y;
| |
| double d;
| |
| | |
| if (RB_TYPE_P(y, T_FIXNUM)) {
| |
| f_y = FIX2LONG(y);
| |
| return DBL2NUM(RFLOAT_VALUE(x) / (double)f_y);
| |
| }
| |
| else if (RB_TYPE_P(y, T_BIGNUM)) {
| |
| d = rb_big2dbl(y);
| |
| return DBL2NUM(RFLOAT_VALUE(x) / d);
| |
| }
| |
| else if (RB_TYPE_P(y, T_FLOAT)) {
| |
| return DBL2NUM(RFLOAT_VALUE(x) / RFLOAT_VALUE(y));
| |
| }
| |
| else {
| |
| return rb_num_coerce_bin(x, y, '/');
| |
| }
| |
| }
| |
| </syntaxhighlight>
| |
| ====<code>float < real → true or false</code>====
| |
| إعادة <code>true</code> إذا كان <code>float</code> أقل من <code>real</code>.
| |
| | |
| نتيجة NaN < NaN غير مُعرَّفة، لذا تُعاد قيمة تعتمد على التنفيذ.<syntaxhighlight lang="ruby">
| |
|
| |
| static VALUE
| |
| flo_lt(VALUE x, VALUE y)
| |
| {
| |
| double a, b;
| |
| | |
| a = RFLOAT_VALUE(x);
| |
| if (RB_TYPE_P(y, T_FIXNUM) || RB_TYPE_P(y, T_BIGNUM)) {
| |
| VALUE rel = rb_integer_float_cmp(y, x);
| |
| if (FIXNUM_P(rel))
| |
| return -FIX2INT(rel) < 0 ? Qtrue : Qfalse;
| |
| return Qfalse;
| |
| }
| |
| else if (RB_TYPE_P(y, T_FLOAT)) {
| |
| b = RFLOAT_VALUE(y);
| |
| #if defined(_MSC_VER) && _MSC_VER < 1300
| |
| if (isnan(b)) return Qfalse;
| |
| #endif
| |
| }
| |
| else {
| |
| return rb_num_coerce_relop(x, y, '<');
| |
| }
| |
| #if defined(_MSC_VER) && _MSC_VER < 1300
| |
| if (isnan(a)) return Qfalse;
| |
| #endif
| |
| return (a < b)?Qtrue:Qfalse;
| |
| }
| |
|
| |
| </syntaxhighlight>
| |
| ====<code>float <= real → true or false</code>====
| |
| إعادة <code>true</code> إذا كان <code>float</code> أقل من أو يساوي <code>real</code>.
| |
| | |
| نتيجة NaN <= NaN غير معرفة، لذا تُعاد قيمة تعتمد على التنفيذ.<syntaxhighlight lang="ruby">
| |
| | |
| static VALUE
| |
| flo_le(VALUE x, VALUE y)
| |
| {
| |
| double a, b;
| |
| | |
| a = RFLOAT_VALUE(x);
| |
| if (RB_TYPE_P(y, T_FIXNUM) || RB_TYPE_P(y, T_BIGNUM)) {
| |
| VALUE rel = rb_integer_float_cmp(y, x);
| |
| if (FIXNUM_P(rel))
| |
| return -FIX2INT(rel) <= 0 ? Qtrue : Qfalse;
| |
| return Qfalse;
| |
| }
| |
| else if (RB_TYPE_P(y, T_FLOAT)) {
| |
| b = RFLOAT_VALUE(y);
| |
| #if defined(_MSC_VER) && _MSC_VER < 1300
| |
| if (isnan(b)) return Qfalse;
| |
| #endif
| |
| }
| |
| else {
| |
| return rb_num_coerce_relop(x, y, idLE);
| |
| }
| |
| #if defined(_MSC_VER) && _MSC_VER < 1300
| |
| if (isnan(a)) return Qfalse;
| |
| #endif
| |
| return (a <= b)?Qtrue:Qfalse;
| |
| }
| |
|
| |
| </syntaxhighlight>
| |
| ====<code>float <=> real → -1, 0, +1, or nil</code>====
| |
| إعادة -1 ، 0 أو +1 اعتمادًا على ما إذا كان <code>float</code> أقل من أو يساوي أو أكبر من <code>real</code>. هذا هو أساس الاختبارات في وحدة [[Ruby/Comparable|Comparable]].
| |
| | |
| نتيجة NaN <=> NaN غير مُعرَّفة، لذا تُعاد قيمة تعتمد علي التنفيذ.
| |
| | |
| إعادة <code>nil</code> إذا كانت القيمتين غير صالحتين للمقارنة.<syntaxhighlight lang="ruby">
| |
| | |
| static VALUE
| |
| flo_cmp(VALUE x, VALUE y)
| |
| {
| |
| double a, b;
| |
| VALUE i;
| |
| | |
| a = RFLOAT_VALUE(x);
| |
| if (isnan(a)) return Qnil;
| |
| if (RB_TYPE_P(y, T_FIXNUM) || RB_TYPE_P(y, T_BIGNUM)) {
| |
| VALUE rel = rb_integer_float_cmp(y, x);
| |
| if (FIXNUM_P(rel))
| |
| return INT2FIX(-FIX2INT(rel));
| |
| return rel;
| |
| }
| |
| else if (RB_TYPE_P(y, T_FLOAT)) {
| |
| b = RFLOAT_VALUE(y);
| |
| }
| |
| else {
| |
| if (isinf(a) && (i = rb_check_funcall(y, rb_intern("infinite?"), 0, 0)) != Qundef) {
| |
| if (RTEST(i)) {
| |
| int j = rb_cmpint(i, x, y);
| |
| j = (a > 0.0) ? (j > 0 ? 0 : +1) : (j < 0 ? 0 : -1);
| |
| return INT2FIX(j);
| |
| }
| |
| if (a > 0.0) return INT2FIX(1);
| |
| return INT2FIX(-1);
| |
| }
| |
| return rb_num_coerce_cmp(x, y, id_cmp);
| |
| }
| |
| return rb_dbl_cmp(a, b);
| |
| }
| |
|
| |
| </syntaxhighlight>
| |
| ====<code>float == obj → true or false</code>====
| |
| إعادة <code>true</code> فقط إذا كانت قيمة <code>obj</code> نفس قيمة <code>float</code>. علي عكس ذلك تحتاج <code>#eql?</code> أن يكون <code>obj</code> من النوع Float.<syntaxhighlight lang="ruby">
| |
| 1.0 == 1 #=> true
| |
| | |
| </syntaxhighlight>نتيجة NaN == NaN غير مُعرَّفة، لذا تُعاد قيمة تعتمد علي التنفيذ.<syntaxhighlight lang="ruby">
| |
|
| |
| VALUE
| |
| rb_float_equal(VALUE x, VALUE y)
| |
| {
| |
| volatile double a, b;
| |
| | |
| if (RB_TYPE_P(y, T_FIXNUM) || RB_TYPE_P(y, T_BIGNUM)) {
| |
| return rb_integer_float_eq(y, x);
| |
| }
| |
| else if (RB_TYPE_P(y, T_FLOAT)) {
| |
| b = RFLOAT_VALUE(y);
| |
| #if defined(_MSC_VER) && _MSC_VER < 1300
| |
| if (isnan(b)) return Qfalse;
| |
| #endif
| |
| }
| |
| else {
| |
| return num_equal(x, y);
| |
| }
| |
| a = RFLOAT_VALUE(x);
| |
| #if defined(_MSC_VER) && _MSC_VER < 1300
| |
| if (isnan(a)) return Qfalse;
| |
| #endif
| |
| return (a == b)?Qtrue:Qfalse;
| |
| }
| |
|
| |
| </syntaxhighlight>
| |
| ====<code>float == obj → true or false</code>====
| |
| إعادة <code>true</code> فقط إذا كانت قيمة <code>obj</code> نفس قيمة <code>float</code>. علي عكس ذلك تحتاج <code>#eql?</code> أن يكون <code>obj</code> من نوع Float.
| |
| | |
| نتيجة NaN == NaN غير مُعرَّفة، لذا تُعاد قيمة تعتمد علي التنفيذ.<syntaxhighlight lang="ruby">
| |
| VALUE
| |
| rb_float_equal(VALUE x, VALUE y)
| |
| {
| |
| volatile double a, b;
| |
| | |
| if (RB_TYPE_P(y, T_FIXNUM) || RB_TYPE_P(y, T_BIGNUM)) {
| |
| return rb_integer_float_eq(y, x);
| |
| }
| |
| else if (RB_TYPE_P(y, T_FLOAT)) {
| |
| b = RFLOAT_VALUE(y);
| |
| #if defined(_MSC_VER) && _MSC_VER < 1300
| |
| if (isnan(b)) return Qfalse;
| |
| #endif
| |
| }
| |
| else {
| |
| return num_equal(x, y);
| |
| }
| |
| a = RFLOAT_VALUE(x);
| |
| #if defined(_MSC_VER) && _MSC_VER < 1300
| |
| if (isnan(a)) return Qfalse;
| |
| #endif
| |
| return (a == b)?Qtrue:Qfalse;
| |
| }
| |
| </syntaxhighlight>
| |
| ====<code>float > real → true or false</code>====
| |
| إعادة <code>true</code> إذا كان <code>float</code> أكبر من <code>real</code>.
| |
| | |
| نتيجة NaN > NaN غير مُعرَّفة، لذا تُعاد قيمة تعتمد علي التنفيذ.<syntaxhighlight lang="ruby">
| |
|
| |
| VALUE
| |
| rb_float_gt(VALUE x, VALUE y)
| |
| {
| |
| double a, b;
| |
| | |
| a = RFLOAT_VALUE(x);
| |
| if (RB_TYPE_P(y, T_FIXNUM) || RB_TYPE_P(y, T_BIGNUM)) {
| |
| VALUE rel = rb_integer_float_cmp(y, x);
| |
| if (FIXNUM_P(rel))
| |
| return -FIX2INT(rel) > 0 ? Qtrue : Qfalse;
| |
| return Qfalse;
| |
| }
| |
| else if (RB_TYPE_P(y, T_FLOAT)) {
| |
| b = RFLOAT_VALUE(y);
| |
| #if defined(_MSC_VER) && _MSC_VER < 1300
| |
| if (isnan(b)) return Qfalse;
| |
| #endif
| |
| }
| |
| else {
| |
| return rb_num_coerce_relop(x, y, '>');
| |
| }
| |
| #if defined(_MSC_VER) && _MSC_VER < 1300
| |
| if (isnan(a)) return Qfalse;
| |
| #endif
| |
| return (a > b)?Qtrue:Qfalse;
| |
| }
| |
| </syntaxhighlight>
| |
| ====<code>float >= real → true or false</code>====
| |
| إعادة <code>true</code> إذا كان <code>float</code> أكبر من أو يساوي <code>real</code>.
| |
| | |
| نتيجة NaN >= NaN غير معرفة، لذا تُعاد قيمة تعتمد على التنفيذ.<syntaxhighlight lang="ruby">
| |
| | |
| static VALUE
| |
| flo_ge(VALUE x, VALUE y)
| |
| {
| |
| double a, b;
| |
| | |
| a = RFLOAT_VALUE(x);
| |
| if (RB_TYPE_P(y, T_FIXNUM) || RB_TYPE_P(y, T_BIGNUM)) {
| |
| VALUE rel = rb_integer_float_cmp(y, x);
| |
| if (FIXNUM_P(rel))
| |
| return -FIX2INT(rel) >= 0 ? Qtrue : Qfalse;
| |
| return Qfalse;
| |
| }
| |
| else if (RB_TYPE_P(y, T_FLOAT)) {
| |
| b = RFLOAT_VALUE(y);
| |
| #if defined(_MSC_VER) && _MSC_VER < 1300
| |
| if (isnan(b)) return Qfalse;
| |
| #endif
| |
| }
| |
| else {
| |
| return rb_num_coerce_relop(x, y, idGE);
| |
| }
| |
| #if defined(_MSC_VER) && _MSC_VER < 1300
| |
| if (isnan(a)) return Qfalse;
| |
| #endif
| |
| return (a >= b)?Qtrue:Qfalse;
| |
| }
| |
|
| |
| </syntaxhighlight>
| |
| ====<code>abs → 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
| |
| rb_float_abs(VALUE flt)
| |
| {
| |
| double val = fabs(RFLOAT_VALUE(flt));
| |
| return DBL2NUM(val);
| |
| }
| |
|
| |
| </syntaxhighlight>
| |
| ====<code>angle → 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>arg → 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>ceil([ndigits]) → integer or float</code>====
| |
| إعادة أصغر رقم أكبر من أو يساوي <code>float</code> مع دقة <code>ndigits</code> رقم (القيمة الافتراضية: 0).
| |
| | |
| عندما تكون الدقة سالبة، تكون القيمة المُعادة عدد صحيح متبوعًا بعدد أصفار مقداره <code>ndigits.abs</code> على الأقل.
| |
| | |
| إعادة عدد عشري عندما يكون <code>ndigits</code> موجبًا، وإلا يُعاد عددٌ صحيحٌ.<syntaxhighlight lang="ruby">
| |
| 1.2.ceil #=> 2
| |
| 2.0.ceil #=> 2
| |
| (-1.2).ceil #=> -1
| |
| (-2.0).ceil #=> -2
| |
| | |
| 1.234567.ceil(2) #=> 1.24
| |
| 1.234567.ceil(3) #=> 1.235
| |
| 1.234567.ceil(4) #=> 1.2346
| |
| 1.234567.ceil(5) #=> 1.23457
| |
| | |
| 34567.89.ceil(-5) #=> 100000
| |
| 34567.89.ceil(-4) #=> 40000
| |
| 34567.89.ceil(-3) #=> 35000
| |
| 34567.89.ceil(-2) #=> 34600
| |
| 34567.89.ceil(-1) #=> 34570
| |
| 34567.89.ceil(0) #=> 34568
| |
| 34567.89.ceil(1) #=> 34567.9
| |
| 34567.89.ceil(2) #=> 34567.89
| |
| 34567.89.ceil(3) #=> 34567.89
| |
| </syntaxhighlight>يُلاحظ أن الدقة المحدودة للنقطة العائمة الحسابية قد تؤدي إلى نتائج مُدهشة:<syntaxhighlight lang="ruby">
| |
| (2.1 / 0.7).ceil #=> 4 (!)
| |
| | |
| </syntaxhighlight>
| |
| ====<code>coerce(numeric) → array</code>====
| |
| إعادة مصفوفة يتمثَّل فيها كلٌ من <code>numeric</code> و <code>float</code> ككائنات Float.
| |
| | |
| ويتحقق ذلك عن طريق تحويل numeric إلى Float.<syntaxhighlight lang="ruby">
| |
| 1.2.coerce(3) #=> [3.0, 1.2]
| |
| 2.5.coerce(1.1) #=> [1.1, 2.5]
| |
| </syntaxhighlight>
| |
| ====<code>denominator → integer</code>====
| |
| إعادة المقام (موجب دائمًا). والنتيجة تعتمد على الآلة.
| |
| | |
| انظر أيضا <code>#numerator</code>.<syntaxhighlight lang="ruby">
| |
| | |
| static VALUE
| |
| float_denominator(VALUE self)
| |
| {
| |
| double d = RFLOAT_VALUE(self);
| |
| VALUE r;
| |
| if (isinf(d) || isnan(d))
| |
| return INT2FIX(1);
| |
| r = float_to_r(self);
| |
| if (canonicalization && k_integer_p(r)) {
| |
| return ONE;
| |
| }
| |
| return nurat_denominator(r);
| |
| }
| |
| </syntaxhighlight>
| |
| ====<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">
| |
| | |
| VALUE
| |
| rb_float_eql(VALUE x, VALUE y)
| |
| {
| |
| 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
| |
| flo_quo(VALUE x, VALUE y)
| |
| {
| |
| 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
| |
| rb_flo_is_finite_p(VALUE num)
| |
| {
| |
| double value = RFLOAT_VALUE(num);
| |
| | |
| #ifdef HAVE_ISFINITE
| |
| if (!isfinite(value))
| |
| return Qfalse;
| |
| #else
| |
| if (isinf(value) || isnan(value))
| |
| return Qfalse;
| |
| #endif
| |
| | |
| return Qtrue;
| |
| }
| |
|
| |
| </syntaxhighlight>
| |
| ====<code>floor([ndigits]) → integer or float</code>====
| |
| إعادة أكبر رقم أصغر من أو يساوي <code>float</code> مع دقة <code>ndigits</code> رقم عشري (القيمة الافتراضية: 0).
| |
| | |
| عندما تكون الدقة سالبة، تكون القيمة المُعادة عدد صحيح متبوعًا بعدد أصفار مقداره <code>ndigits.abs</code> على الأقل.
| |
| | |
| إعادة عدد عشري عندما يكون <code>ndigits</code> موجبًا، وإلا يُعاد عددٌ صحيحٌ.<syntaxhighlight lang="ruby">
| |
| 1.2.floor #=> 1
| |
| 2.0.floor #=> 2
| |
| (-1.2).floor #=> -2
| |
| (-2.0).floor #=> -2
| |
| | |
| 1.234567.floor(2) #=> 1.23
| |
| 1.234567.floor(3) #=> 1.234
| |
| 1.234567.floor(4) #=> 1.2345
| |
| 1.234567.floor(5) #=> 1.23456
| |
| | |
| 34567.89.floor(-5) #=> 0
| |
| 34567.89.floor(-4) #=> 30000
| |
| 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>hash → integer</code>====
| |
| إعادة رمز التجزئة لهذا الرقم العشري.
| |
|
| |
|
| راجع أيضًا <code>Object#hash</code>.<syntaxhighlight lang="ruby">
| | * <code>1</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>2</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>3</code>: التقريب نحو اللانهاية السالبة. |
| fy = (double)FIX2LONG(y);
| |
| }
| |
| 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/mod|%]]</code>=== |
|
| | يعيد باقي عملية قسمة عدد عشري على عدد آخر. |
| </syntaxhighlight>
| |
| ====<code>negative? → true or false</code>====
| |
| إعادة <code>true</code> إذا كان <code>float</code> أقل من 0.<syntaxhighlight lang="ruby">
| |
|
| |
|
| static VALUE
| | ===<code>[[Ruby/Float/multiplication|*]]</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/expo|**]]</code>=== |
| | يعيد ناتج عملية رفع عدد عشري (الأساس) إلى قوة عدد محدد (الأس). |
|
| |
|
| <code>Float::NAN.next_float</code> هو <code>Float::NAN</code>. | | ===<code>[[Ruby/Float/plus|+]]</code>=== |
| | يعيد ناتج عملية الجمع بين عددين. |
|
| |
|
| فعلى سبيل المثال:<syntaxhighlight lang="ruby">
| | ===<code>[[Ruby/Float/minus|-]]</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/negation|-]]</code>=== |
| 1.0.next_float - 1.0 #=> 2.220446049250313e-16
| | إن استُعمِل هذا المعامل بالشكل <code>-Float</code>، فسيعيد القيمة المعاكسة للعدد <code>Float</code> العشري (أي القيمة السالبة إن كان <code>Float</code> موجبًا أو العكس بالعكس). |
| 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/division|/]]</code>=== |
| #=> 0x1.47ae147ae147bp-7 0.01
| | يعيد ناتج عملية القسمة بين عدد عشري وعدد آخر. |
| # 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/lt|>]]</code>=== |
| 100.times { f += 0.1 }
| | يعيد القيمة <code>true</code> إن كانت قيمة العدد العشري الواقع على يساره أصغر من قيمة العدد المواقع على يمينه. |
| 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/le|=>]]</code>=== |
| | يعيد القيمة <code>true</code> إن كانت قيمة العدد العشري الواقع على يساره أصغر من أو تساوي قيمة العدد الواقع على يمينه. |
|
| |
|
| static VALUE
| | ===<code>[[Ruby/Float/comparison|<=>]]</code>=== |
| float_numerator(VALUE self)
| | يعيد عددًا صحيحًا (-1 أو 0 أو +1) إذا كان العدد العشري الواقع على يساره أصغر من أو يساوي أو أكبر من العدد الآخر الواقع على يمينه على التوالي. |
| {
| |
| 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/equal|==]]</code>=== |
| | يعيد القيمة <code>true</code> إن كان العدد العشري الواقع على يساره يساوي القيمة الواقعة على يمينه. |
|
| |
|
| <code>Float::NAN.prev_float</code> هو <code>Float::NAN</code>. | | ===<code>[[Ruby/Float/gt|<]]</code>=== |
| | يعيد القيمة <code>true</code> إن كانت قيمة العدد العشري الواقع على يساره أكبر من قيمة العدد الآخر الواقع على يمينه. |
|
| |
|
| فعلى سبيل المثال:<syntaxhighlight lang="ruby">
| | ===<code>[[Ruby/Float/ge|=<]]</code>=== |
| 0.01.prev_float #=> 0.009999999999999998
| | يعيد القيمة <code>true</code> إن كانت قيمة العدد العشري الواقع على يساره أكبر من أو تساوي قيمة العدد الآخر الواقع على يمينه. |
| 1.0.prev_float #=> 0.9999999999999999
| |
| 100.0.prev_float #=> 99.99999999999999
| |
|
| |
|
| 0.01 - 0.01.prev_float #=> 1.734723475976807e-18
| | ===<code>[[Ruby/Float/abs|abs]]</code>=== |
| 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 }
| | ===<code>[[Ruby/Float/angle|angle]]</code>=== |
| #=> 0x1.47ae147ae147bp-7 0.01
| | يعيد القيمة <code>0</code> إن كان العدد العشري الذي استُدعي معه موجبًا، أو القيمة <code>[[Ruby/Math/PI|pi]]</code> خلاف ذلك. |
| # 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
| | ===<code>[[Ruby/Float/arg|arg]]</code>=== |
| flo_quo(VALUE x, VALUE y)
| | يعيد القيمة <code>0</code> إن كان العدد العشري الذي استُدعي معه موجبًا، أو القيمة <code>[[Ruby/Math/PI|pi]]</code> خلاف ذلك. |
| {
| |
| 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
| | ===<code>[[Ruby/Float/ceil|ceil]]</code>=== |
| float_rationalize(int argc, VALUE *argv, VALUE self)
| | يعيد أصغر عدد من الأعداد الأكبر من أو تساوي العدد العشري الذي استُدعي معه وبدقة محدَّدة. |
| {
| |
| VALUE e;
| |
| double d = RFLOAT_VALUE(self);
| |
|
| |
|
| if (d < 0.0)
| | ===<code>[[Ruby/Float/coerce|coerce]]</code>=== |
| return rb_rational_uminus(float_rationalize(argc, argv, DBL2NUM(-d)));
| | يحول العدد المستدعى معها والعدد العشري المُمرَّر إليها إلى النوع <code>[[Ruby/Float|Float]]</code> ويعيدهما في مصفوفة. |
|
| |
|
| rb_scan_args(argc, argv, "01", &e);
| | ===<code>[[Ruby/Float/denominator|denominator]]</code>=== |
| | يعيد المقام (denominator) للعدد الكسري الذي استدعي معه، ويكون دائمًا موجبًا. |
|
| |
|
| if (argc != 0) {
| | ===<code>[[Ruby/Float/divmod|divmod]]</code>=== |
| return rb_flt_rationalize_with_prec(self, e);
| | يعيد مصفوفة تحتوي على حاصل (quotient) وباقي قسمة العدد الذي استُدعي معه على العدد المُمرَّر إليه. |
| }
| |
| else {
| |
| return rb_flt_rationalize(self);
| |
| }
| |
| }
| |
|
| |
| </syntaxhighlight><code>round([ndigits] [, half: mode]) → integer or float</code>
| |
|
| |
|
| إعادة <code>float</code> مُقرَّب إلى أقرب قيمة بدقة أرقام عشرية مقدارها <code>ndigits</code> (القيمة الافتراضية: 0).
| | ===<code>[[Ruby/Float/eql-3F|eql?]]</code>=== |
| | يتحقق إن كان العدد الذي استُدعي معه والعدد المُمرَّر إليه من نفس النوع (أي كلاهما عدد عشري) ومتساويين في القيمة. |
|
| |
|
| عندما تكون الدقة سالبة، تكون القيمة المُعادة عدد صحيح متبوعًا بعدد أصفار مقداره <code>ndigits.abs</code> على الأقل.
| | ===<code>[[Ruby/Float/fdiv|fdiv]]</code>=== |
| | يجري عملية القسمة بين العدد الذي استدعي معه والعدد الذي مُرِّر إليه ثم يعيد الناتج في عدد <nowiki/>[[Ruby/Float|عشري]]. |
|
| |
|
| إعادة عدد عشري عندما يكون <code>ndigits</code> موجبًا، وإلا يُعاد عددٌا صحيحٌا.<syntaxhighlight lang="ruby">
| | ===<code>[[Ruby/Float/finite-3F|finite?]]</code>=== |
| 1.4.round #=> 1
| | يتحقق إذا كان العدد العشري الذي استدعي معه عددًا عشريًّا صالحًا وفقًا لمعيار IEEE؛ أي أنه ليس عددٌ لا نهائي ويعيد التابع <code>nan?</code> القيمة <code>false</code> معه. |
| 1.5.round #=> 2
| |
| 1.6.round #=> 2
| |
| (-1.5).round #=> -2
| |
|
| |
|
| 1.234567.round(2) #=> 1.23
| | ===<code>[[Ruby/Float/floor|floor]]</code>=== |
| 1.234567.round(3) #=> 1.235
| | يعيد أكبر عدد من الأعداد الأصغر من أو تساوي العدد العشري الذي استُدعي معه وبدقة محدَّدة. |
| 1.234567.round(4) #=> 1.2346
| |
| 1.234567.round(5) #=> 1.23457
| |
|
| |
|
| 34567.89.round(-5) #=> 0
| | ===<code>[[Ruby/Float/hash|hash]]</code>=== |
| 34567.89.round(-4) #=> 30000
| | يعيد القيمة hash للعدد العشري الذي استدعي معه. |
| 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>[[Ruby/Float/infinite-3F|infinite?]]</code>=== |
| بما أن <code>float</code> هو بالأصل Float، يُعيد <code>self</code>.<syntaxhighlight lang="ruby">
| | يتحقق إذا ما إن كان العدد الذي استدعي معه منتهيًا (finite) أو غير منتهي من الطرف السالب (<code>-Infinity</code>) أو غير منتهي من الطرف الموجب (<code>+Infinity</code>). |
|
| |
|
| static VALUE
| | ===<code>[[Ruby/Float/inspect|inspect]]</code>=== |
| flo_to_f(VALUE num)
| | هو اسم بديل للتابع <code>to_s</code>. |
| {
| |
| return num;
| |
| }
| |
|
| |
| </syntaxhighlight> | |
|
| |
|
| ==== <code>to_i → integer</code> ====
| | ===<code>[[Ruby/Float/magnitude|magnitude]]</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">
| | ===<code>[[Ruby/Float/modulo|modulo]]</code>=== |
| | يعيد باقي عملية قسمة العدد العشري الذي استُدعي معه على العدد المُعطى. |
|
| |
|
| static VALUE
| | ===<code>[[Ruby/Float/nan-3F|nan?]]</code>=== |
| flo_to_i(VALUE num)
| | يتحقق إذا كان العدد العشري الذي استدعي معه عددًا عشريًّا غير صالح وفقًا لمعيار IEEE. |
| {
| |
| double f = RFLOAT_VALUE(num);
| |
|
| |
|
| if (f > 0.0) f = floor(f);
| | ===<code>[[Ruby/Float/negative-3F|negative?]]</code>=== |
| if (f < 0.0) f = ceil(f);
| | يتحقق إن كان العدد العشري الذي استُدعي معه عددًا سالبًا. |
|
| |
|
| return dbl2ival(f);
| | ===<code>[[Ruby/Float/next_float|next_float]]</code>=== |
| }
| | يعيد العدد العشري الذي يلي العدد العشري الذي استُدعي معه. |
|
| |
| </syntaxhighlight> | |
|
| |
|
| ==== <code>to_int → integer</code> ====
| | ===<code>[[Ruby/Float/numerator|numerator]]</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"> | | ===<code>[[Ruby/Float/phase|phase]]</code>=== |
| | يعيد القيمة <code>0</code> إن كان العدد العشري الذي استُدعي معه موجبًا، أو يعيد القيمة <code>[[Ruby/Math/PI|pi]]</code>خلاف ذلك. |
|
| |
|
| static VALUE
| | ===<code>[[Ruby/Float/positive-3F|positive?]]</code>=== |
| flo_to_i(VALUE num)
| | يتحقق إن كان العدد العشري الذي استُدعي معه عددًا موجبًا. |
| {
| |
| double f = RFLOAT_VALUE(num);
| |
|
| |
|
| if (f > 0.0) f = floor(f);
| | ===<code>[[Ruby/Float/prev_float|prev_float]]</code>=== |
| if (f < 0.0) f = ceil(f);
| | يعيد العدد العشري الذي يسبق العدد العشري الذي استُدعي معه. |
|
| |
|
| return dbl2ival(f);
| | ===<code>[[Ruby/Float/quo|quo]]</code>=== |
| }
| | يعيد ناتج قسم العدد العشري المستدعى معه على العدد العشري المُمرَّر إليه. |
|
| |
| </syntaxhighlight> | |
|
| |
|
| ==== <code>to_r → rational</code> ====
| | ===<code>[[Ruby/Float/rationalize|rationalize]]</code>=== |
| إعادة قيمة نسبية.<syntaxhighlight lang="ruby">
| | يعيد قيمة تقريبة بسيطة (<code>flt-|eps| <= result <= flt+|eps|</code>) للعدد العشري الذي استدعي معه. |
| 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);
| | ===<code>[[Ruby/Float/round|round]]</code>=== |
| #if FLT_RADIX == 2
| | يقرِّب العدد الذي استُدعي معه إلى أقرب قيمة بدقة محدَّدة. |
| {
| |
| long ln = FIX2LONG(n);
| |
|
| |
|
| if (ln == 0)
| | ===<code>[[Ruby/Float/to_f|to_f]]</code>=== |
| 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)) {
| | ===<code>[[Ruby/Float/to_i|to_i]]</code>=== |
| static const char minf[] = "-Infinity";
| | يحول العدد العشري الذي استُدعي معه إلى <nowiki/>[[Ruby/Integer|عدد صحيح]]. |
| 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);
| | ===<code>[[Ruby/Float/to_int|to_int]]</code>=== |
| s = sign ? rb_usascii_str_new_cstr("-") : rb_usascii_str_new(0, 0);
| | يحول العدد العشري الذي استُدعي معه إلى <nowiki/>[[Ruby/Integer|عدد صحيح]]. |
| 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>[[Ruby/Float/to_r|to_r]]</code>=== |
| إعادة <code>float</code> مبتورًا (نحو الصفر) إلى دقة أرقام عشرية <code>ndigits</code> (القيمة الافتراضية: 0).
| | يحول العدد العشري الذي استُدعي معه إلى <nowiki/>[[Ruby/Rational|عدد جذري]] (rational). |
|
| |
|
| عندما تكون الدقة سالبة، تكون القيمة المُعادة عدد صحيح متبوعًا بعدد أصفار مقداره <code>ndigits.abs</code> على الأقل.
| | ===<code>[[Ruby/Float/to_s|to_s]]</code>=== |
| | يحول العدد العشري الذي استدعي معه إلى سلسلة نصية. |
|
| |
|
| إعادة عدد عشري عندما يكون <code>ndigits</code> موجبًا، وإلا يُعاد عددٌ صحيحٌ.<syntaxhighlight lang="ruby">
| | ===<code>[[Ruby/Float/truncate|truncate]]</code>=== |
| 2.8.truncate #=> 2
| | يعيد العدد العشري الذي استُدعي معه بعد اقتطاعه إلى دقة (precision) محدَّدة. |
| (-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)
| | * <span> </span>[http://ruby-doc.org/core-2.5.1/Float.html صفحة الصنف Float في توثيق روبي الرسمي.] |
| {
| |
| if (RFLOAT_VALUE(num) == 0.0) {
| |
| return Qtrue;
| |
| }
| |
| return Qfalse;
| |
| }
| |
| </syntaxhighlight>
| |
| =مصادر= | |
| * <span> </span>[http://ruby-doc.org/core-2.5.1/Float.html صفحة Float في توثيق روبي الرسمي.] | |
| [[تصنيف:Ruby]] | | [[تصنيف:Ruby]] |
| | [[تصنيف:Ruby Class]] |
| | [[تصنيف:Ruby Float]] |