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

مراجعة 12:55، 13 سبتمبر 2018

يمكن تمثيل الأعداد العقدية (تُسمّى أيضًا أعدادًا مركبة) كزوج مكون من عدد حقيقي ووحدة تخلية (العدد i) ؛ وفق الشكل a+bi، حيث a هو الجزء الحقيقي، و b هو الجزء التخيلي و i هو الوحدة الخيالية.

العدد الحقيقي a يساوي رياضياتيًا العدد العقدي a+0i.

يمكن إنشاء الأعداد العقدية بطريقة حرفية، وأيضا باستخدام التوابع Kernel#Complex أو ‏‎::rect أو ‏‎::polar أو ‎#to_c. إليك الأمثلة التالية:

2+1i                 #=> (2+1i)
Complex(1)           #=> (1+0i)
Complex(2, 3)        #=> (2+3i)
Complex.polar(2, 3)  #=> (-1.9799849932008908+0.2822400161197344i)
3.to_c               #=> (3+0i)

يمكنك أيضا إنشاء الكائنات العقدية من الأعداد من النوع float أو من السلاسل النصية كما توضح الأمثلة التالية:

Complex(0.3)         #=> (0.3+0i)
Complex('0.3-0.5i')  #=> (0.3-0.5i)
Complex('2/3+3/4i')  #=> ((2/3)+(3/4)*i)
Complex('1@2')       #=> (-0.4161468365471424+0.9092974268256817i)

0.3.to_c             #=> (0.3+0i)
'0.3-0.5i'.to_c      #=> (0.3-0.5i)
'2/3+3/4i'.to_c      #=> ((2/3)+(3/4)*i)
'1@2'.to_c           #=> (-0.4161468365471424+0.9092974268256817i)

تُصنّف الأعداد العقدية إلى مضبوطة (exact) أو غير مضبوطة:

Complex(1, 1) / 2    #=> ((1/2)+(1/2)*i)
Complex(1, 1) / 2.0  #=> (0.5+0.5i)

الثوابت

مصادر

قسم الصنف Complex في توثيق روبي الرسمي.

@@ سطر 2: / سطر 2: @@
 [[تصنيف: Ruby]]
 [[تصنيف: Ruby Complex]]
-يُستخدم المخلوط (mixin) ‏<code>Comparable</code> من قبل الأصناف التي يمكن ترتيب كائناتها. يجب أن يحدد الصنفُ المعاملَ <code><=></code> ، الذي يقارن الكائن المستقبِل (receiver ) مع كائن آخر ، ويعيد ‎<code>-1</code>، أو <code>0</code> ، أو ‎<code>+1</code> إن كان المُستقبِل أصغر من الكائن الآخر، أو يساويه: أو أكبر منه على التوالي.  إذا كان الكائن الآخر غير قابل للمقارنة ، فعندئذ سيعيد المعامل <code><=></code> القيمة المعدومة <code>nil</code>.
+يمكن تمثيل الأعداد العقدية (تُسمّى أيضًا أعدادًا مركبة) كزوج مكون من عدد حقيقي ووحدة تخلية (العدد <code>i</code>) ؛ وفق الشكل <code>a+bi</code>، حيث <code>a</code> هو الجزء الحقيقي، و <code>b</code> هو الجزء التخيلي و <code>i</code> هو الوحدة الخيالية.
-يستخدم <code>Comparable</code> المعامل <code><=></code> لإجراء عمليات المقارنة التقليدية (<code><</code>، ‎<code><=‎</code> ، <code>==</code> ،<code>>=‎</code> و<code>></code>) والتابع <code>between?</code>‎.
+العدد الحقيقي <code>a</code> يساوي رياضياتيًا العدد العقدي <code>a+0i</code>.
-== توابع الكائن العامة (Public Instance Methods) ==
+يمكن إنشاء الأعداد العقدية بطريقة حرفية، وأيضا باستخدام التوابع <code>Kernel#Complex</code> أو  ‏‎<code>::rect</code> أو  ‏‎:<code>:polar</code> أو <code>‎#to_c.</code> إليك الأمثلة التالية: <syntaxhighlight lang="ruby">
-=== [[Ruby/Comparable/Greater-3D|المعامل =>]]  ===
++1i                 #=> (2+1i)
- يقارن المعامل <code>‎‎‎<=‎</code> بين كائنين بناءً على النتيجة التي يعيدها المعامل <code><=></code> الخاص بالمُستقبِل (receiver). إذ يعيد القيمة <code>true</code> إن أعاد المعامل <code><=></code> القيمة ‎<code>-1</code>‎ أو <code>0</code>، وإلا فسيعيد <code>false</code>.
+Complex(1)           #=> (1+0i)
+Complex(2, 3)        #=> (2+3i)
+Complex.polar(2, 3)  #=> (-1.9799849932008908+0.2822400161197344i)
+.to_c               #=> (3+0i)
+</syntaxhighlight>يمكنك أيضا إنشاء الكائنات العقدية من الأعداد من النوع  <code>float</code> أو من السلاسل النصية كما توضح الأمثلة التالية: <syntaxhighlight lang="ruby">
+Complex(0.3)         #=> (0.3+0i)
+Complex('0.3-0.5i')  #=> (0.3-0.5i)
+Complex('2/3+3/4i')  #=> ((2/3)+(3/4)*i)
+Complex('1@2')       #=> (-0.4161468365471424+0.9092974268256817i)
-=== [[Ruby/Comparable/equal|المعامل ==]] ===
+.3.to_c             #=> (0.3+0i)
-يعيد المعامل القيمة <code>true</code> إن أعاد المعامل <code><=></code> القيمة ‎ <code>0</code>أو كان الكائنان ''<code>obj</code>'' و ''<code>other</code>'' متساويين، خلا ذلك سيعيد <code>false</code>.
+'0.3-0.5i'.to_c      #=> (0.3-0.5i)
+'2/3+3/4i'.to_c      #=> ((2/3)+(3/4)*i)
+'1@2'.to_c           #=> (-0.4161468365471424+0.9092974268256817i)
+</syntaxhighlight>تُصنّف الأعداد العقدية إلى مضبوطة (exact) أو غير مضبوطة: <syntaxhighlight lang="ruby">
+Complex(1, 1) / 2    #=> ((1/2)+(1/2)*i)
+Complex(1, 1) / 2.0  #=> (0.5+0.5i)
+</syntaxhighlight>
-===[[Ruby/Comparable/Greater Than|المعامل >]] ===
+== الثوابت ==
-يقارن المعامل <code>></code> بين كائنين بناءً على النتيجة التي يعيدها المعامل <code><=></code> الخاص بالمُستقبِل (receiver). إذ يعيد القيمة <code>true</code> إن أعاد المعامل <code><=></code> القيمة ‎<code>-1</code>‎ ، وإلا فسيعيد <code>false</code>.
-===[[Ruby/Comparable/Less-3D|المعامل <code>‎‎‎>=‎</code>]] ===
-يقارن المعامل <code><</code> بين كائنين بناءً على النتيجة التي يعيدها المعامل <code><=></code> الخاص بالمُستقبِل (receiver). إذ يعيد القيمة <code>true</code> إن أعاد المعامل <code><=></code> القيمة ‎<code>1</code>‎  أو <code>0</code>، وإلا فسيعيد <code>false</code>.
-===[[Ruby/Comparable/Less than|المعامل <]] ===
-يقارن المعامل <code><</code> بين كائنين بناءً على النتيجة التي يعيدها المعامل <code><=></code> الخاص بالمُستقبِل (receiver). إذ يعيد القيمة <code>true</code> إن أعاد المعامل <code><=></code> القيمة ‎<code>1</code>‎ ، وإلا فسيعيد <code>false</code>.
-=== [[Ruby/Comparable/clamp|التابع ‎<code>clamp</code>‎]] ===
-يعيد التابع ‎<code>clamp</code>‎الوسيط المُعطى <code>min</code> (أنظر فقرة البنية العامة) إن كان عائد <code>''obj'' <=> ''min''</code> ''أقل من <code>0</code>، أو يعيد <code>max</code> (أنظر فقرة البنية العامة) إن كان عائد <code>obj <=> max</code> أكبر  من <code>0</code>، خلا ذلك سيعيد الكائنَ <code>obj </code> الذي استدعي معه.''
-===[[Ruby/Comparable/between-3F|التابع<code>‎between?‎</code>]] ===
-يتحقق التابع ‎<code>between?</code>‎مما إذا كان الكائن الذي استُدعي معه محصورا بين الكائنين المٌمرّرين إليه.
 == مصادر ==
-* [http://ruby-doc.org/core-2.5.1/Comparable.html#method-i-between-3F قسم  الصنف Complex في توثيق روبي الرسمي.]
+* [http://ruby-doc.org/core-2.5.1/Complex.html قسم  الصنف Complex في توثيق روبي الرسمي.]