numpy --- عمليات المصفوفات المتوافقة مع numpy

توفر الوحدة الفرعية numpy من ulab واجهة برمجة تطبيقات متوافقة مع numpy مبنية حول نوع المصفوفة متعددة الأبعاد ndarray. وهي تنفذ مجموعة فرعية منتقاة من numpy الخاصة بـ CPython: إنشاء المصفوفات، والعمليات الحسابية على مستوى العناصر، والاختزالات والإحصاءات، والجبر الخطي، وتحويلات فورييه السريعة، وتوليد الأرقام العشوائية، وملاءمة كثيرات الحدود، والإدخال/الإخراج الأساسي.

تُستورد الوحدة الفرعية اصطلاحاً باسم np

from ulab import numpy as np

a = np.array([1, 2, 3, 4], dtype=np.float)
b = np.linspace(0, 1, num=5)
c = np.dot(a.reshape((2, 2)), a.reshape((2, 2)))

كل وسيط dtype هو أحد الثوابت الصحيحة المعروضة على مستوى الوحدة: numpy.bool، وnumpy.uint8، وnumpy.int8، وnumpy.uint16، وnumpy.int16، وnumpy.float (الافتراضي)، و(عند تجميع دعم الأعداد المركبة) numpy.complex. ويشير نوع النتيجة ndarray إلى numpy.ndarray.

الوحدات الفرعية

• numpy.fft --- إجراءات تحويل فورييه السريع
• numpy.linalg --- إجراءات الجبر الخطي
• numpy.random --- توليد الأعداد العشوائية

صنف ndarray --- المصفوفة متعددة الأبعاد

إن ndarray هو الحاوية متعددة الأبعاد المدركة للنوع dtype والتي تشكل جوهر numpy / ulab. تُخزَّن البيانات في كتلة متجاورة يصف تفسيرها ترويسة صغيرة (dtype، وshape، وstrides، وndim، وitemsize). تكتفي العديد من العمليات -- مثل reshape، وtranspose، والتقطيع -- بتعديل هذه الترويسة فقط، ولذلك فهي زهيدة التكلفة جداً؛ أما الطرق التي تخصص ذاكرة جديدة (copy، وflatten، ومعظم العمليات الحسابية) فتُرجع مصفوفة كثيفة جديدة.

يمكن الوصول إلى النوع نفسه عبر ulab.ndarray، وnumpy.ndarray، و(ضمن هذه الصفحة) ببساطة ndarray.

class numpy.ndarray(values: ndarray | bytes | list | tuple, *, dtype: int = numpy.float)

إنشاء ndarray جديدة.

المعاملات:

• values -- البيانات المصدرية. إما ndarray أخرى (يجري نسخها نسخاً عميقاً، مع تحويل النوع إذا اختلف dtype) أو أي عنصر قابل للتكرار في MicroPython. تنتج العناصر المتداخلة القابلة للتكرار مصفوفات متعددة الأبعاد؛ ويجب أن تكون جميع العناصر الداخلية القابلة للتكرار بالطول نفسه وإلا يُطلق ValueError.

• dtype -- نوع العناصر للمصفوفة الجديدة. أحد الأعداد الصحيحة لرمز النوع المعروضة بواسطة numpy (numpy.bool، وnumpy.uint8، وnumpy.int8، وnumpy.uint16، وnumpy.int16، وnumpy.float، و-- عند الدعم -- numpy.complex)، أو نسخة dtype. القيمة الافتراضية هي numpy.float.

إن الدالة المصنّعة numpy.array هي الطريقة الاصطلاحية لإنشاء ndarray؛ وهي تمرر إلى هذا المُنشئ.

byteswap(*, inplace: bool = False) → ndarray

تبديل ترتيب البايتات لكل عنصر. بالنسبة لمصفوفات uint16، وint16، وfloat، وcomplex يعكس هذا ترتيب البايتات لكل عنصر، وهو مفيد عند استهلاك بيانات من الطرفيات التي لا يطابق ترتيب البايتات فيها ترتيب المتحكم الدقيق. أما بالنسبة لأنواع dtype أحادية البايت (bool، وuint8، وint8) فهذه عملية لا تأثير لها تُرجع عرضاً أو نسخة.

إذا كانت inplace تساوي False (الافتراضي) تُرجع ndarray جديدة وتُترك الأصلية دون مساس. وإذا كانت inplace تساوي True تُبدَّل بايتات self في مكانها ويُرجع عرض لـ self.

copy() → ndarray

إرجاع نسخة عميقة كثيفة جديدة من المصفوفة. تمتلك النسخة بياناتها الخاصة؛ ولا تؤثر التعديلات عليها في الأصل.

flatten(*, order: str = 'C') → ndarray

إرجاع نسخة أحادية البعد جديدة من المصفوفة.

المعاملات:

order -- تتنقل 'C' (الافتراضي) عبر البيانات بترتيب C (يتغير المحور الأخير أسرع)؛ وتتنقل 'F' عبرها بترتيب Fortran (يتغير المحور الأول أسرع).

reshape(shape: int | tuple[int, ...]) → ndarray

إرجاع عرض للمصفوفة بشكل جديد. يجب أن يبقى العدد الإجمالي للعناصر دون تغيير وإلا يُطلق ValueError. متاح فقط عندما ULAB_MAX_DIMS > 1. يكافئ الإسناد إلى shape.

sort(*, axis: int | None = -1) → None

فرز المصفوفة في مكانها.

المعاملات:

axis -- المحور الذي يجري الفرز على امتداده. تفرز -1 (الافتراضي) على امتداد المحور الأخير؛ بينما تسطح None المصفوفة أولاً ثم تفرزها.

tobytes() → bytearray

إرجاع bytearray يشكل اسماً مستعاراً لمخزن البيانات الأساسي للمصفوفة. تعدل الكتابة عبر bytearray المُرجعة المصفوفة في مكانها. يُطلق ValueError إذا لم تكن المصفوفة كثيفة (مثل عرض مقتطع).

tolist() → list

إرجاع محتويات المصفوفة على شكل list بايثونية (قد تكون متداخلة). يساوي عمق التداخل ndim.

transpose() → ndarray

إرجاع منقول المصفوفة (المحاور معكوسة). بالنسبة للمصفوفات أحادية البعد يُرجع هذا self. متاح فقط عندما ULAB_MAX_DIMS > 1. والسمة T هي اختصار لهذه الطريقة.

dtype: dtype | int

نوع بيانات عناصر المصفوفة. يُرجع نسخة dtype عندما يُبنى البرنامج الثابت مع تفعيل ULAB_HAS_DTYPE_OBJECT، وإلا يُرجع رمز النوع الأساسي أحادي الحرف على شكل عدد صحيح.

flat: flatiter

مكرر مسطح يولد كل عنصر من المصفوفة بترتيب C. وخلافاً لـ flatten()، لا يخصص التكرار عبر flat مصفوفة جديدة.

itemsize: int

الحجم بالبايتات لعنصر مصفوفة واحد، مشتق من dtype.

ndim: int

عدد أبعاد المصفوفة (طول shape).

shape: tuple[int, ...]

أطوال المصفوفة على امتداد كل محور. يؤدي إسناد صفّ (tuple) إلى shape إلى إعادة تشكيل المصفوفة في مكانها (يكافئ reshape()).

size: int

العدد الإجمالي للعناصر في المصفوفة (حاصل ضرب shape).

strides: tuple[int, ...]

عدد البايتات اللازم التقدم بها في الذاكرة على امتداد كل محور للوصول إلى العنصر التالي على ذلك المحور.

T: ndarray

منقول المصفوفة؛ يكافئ transpose().

real: ndarray

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

imag: ndarray

الجزء التخيلي من مصفوفة مركبة، يُرجع على شكل ndarray من نوع float. بالنسبة للمصفوفات الحقيقية يكون هذا مصفوفة أصفار بنفس dtype الخاص بـ self. متاح فقط عندما يُبنى البرنامج الثابت مع دعم الأعداد المركبة.

العوامل المدعومة

تدعم نسخ ndarray العوامل التالية. تنشر العوامل الثنائية معاملاتها وفق قواعد البث القياسية في numpy وتتبع قواعد الترقية النوعية في numpy (مثلاً uint8 + int8 => int16، وuint16 + int16 => float)؛ والعمليات التي تتضمن معاملاً مركباً تنتج نتيجة مركبة.

حسابية (ثنائية): +، و-، و*، و/، و//، و%، و**. كما تُدعم المعاملات المنعكسة (الجهة اليمنى) والمتغيرات في المكان +=، و-=، و*=، و/=، و%=، و**=. ويُقبل كل من صيغة ndarray-مع-ndarray وصيغة ndarray-مع-عدد قياسي. والقسمة الأرضية (//) وعامل باقي القسمة (%) غير منفذين لمصفوفات complex.

المقارنة: ==، و!=، و<، و<=، و>، و>=. تُرجع كل منها ndarray منطقية بشكل البث.

على مستوى البتات (المصفوفات الصحيحة فقط): &، و|، و^. ويؤدي تطبيقها على مصفوفة float أو complex إلى إطلاق TypeError.

أحادية: + (تُرجع نسخة)، و- (نفي؛ في أنواع dtype غير المؤشرة تلتف القيم بباقي القسمة على \(2^N\))، وabs() (القيمة المطلقة على مستوى العناصر؛ في أنواع dtype غير المؤشرة تُرجع نسخة دون حساب)، و~ (عكس على مستوى البتات، لأنواع dtype الصحيحة فقط)، وlen() (تُرجع طول المحور الأول).

الفهرسة والتقطيع: تُدعم a[i]، وa[i, j, ...]، وa[start:stop:step]، والفهرسة بقناع منطقي (a[mask])، والفهرسة بمصفوفة صحيحة (المتقنة) كلها في عمليات القراءة والكتابة على حد سواء.

التكرار: يؤدي التكرار عبر ndarray إلى توليد مصفوفات فرعية على امتداد المحور الأول (عنصر واحد في كل مرة للمصفوفات أحادية البعد). استخدم flat للتكرار عبر كل عنصر قياسي بغض النظر عن الأبعاد.

عامل ضرب المصفوفات @ غير منفذ؛ استخدم numpy.dot (np.dot(a, b)) بدلاً منه.

عاملا الإزاحة (<<، و>>) غير منفذين على مستوى العوامل. استخدم numpy.left_shift وnumpy.right_shift للإزاحات الصحيحة على مستوى العناصر.

إنشاء المصفوفات

numpy.array(values: ndarray | list | tuple, *, dtype: int = float) → ndarray

إنشاء ndarray جديدة من عنصر متداخل قابل للتكرار من الأرقام. مُنشئ بديل مكافئ لـ numpy.ndarray.

numpy.arange(start: int | float, stop: int | float | None = None, step: int | float = 1, *, dtype: int | None = None) → ndarray

إرجاع قيم متباعدة بالتساوي على امتداد الفترة نصف المفتوحة [start, stop). إذا أُعطي وسيط موضعي واحد فقط، يُعامَل كـ stop مع start = 0. وإذا حُذف dtype، فيُستنتج من المدخلات (عدد صحيح إذا كانت start وstop وstep جميعها أعداداً صحيحة وضمن المدى).

numpy.asarray(a: ndarray | list | tuple, *, dtype: int | None = None) → ndarray

إذا كانت a بالفعل ndarray يطابق نوع dtype الخاص بها dtype (أو كانت dtype تساوي None)، فأرجع a دون تغيير؛ وإلا فأنشئ مصفوفة جديدة (مع تحويل dtype المطلوب عند إعطائه). تُحوّل العناصر القابلة للتكرار كما في numpy.array.

numpy.concatenate(arrays: tuple, *, axis: int = 0) → ndarray

ضم تسلسل من ndarray على امتداد axis قائم. يجب أن تشترك جميع مصفوفات الإدخال في نفس dtype وndim والشكل على كل محور عدا axis.

numpy.diag(a: ndarray, *, k: int = 0) → ndarray

بالنسبة لـ a ثنائية البعد، أرجع مصفوفة أحادية البعد تحتوي على القطر k. وبالنسبة لـ a أحادية البعد، أرجع مصفوفة مربعة ثنائية البعد مع وضع a على القطر k. وقد تكون k موجبة (فوق القطر الرئيسي) أو سالبة (تحته).

numpy.empty(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray

اسم مستعار لـ zeros؛ يُرجع مصفوفة معبأة بالأصفار من shape وdtype. (لا تترك ulab المخزن غير مهيأ.)

numpy.eye(N: int, M: int | None = None, k: int = 0, *, dtype: int = float) → ndarray

إرجاع مصفوفة ثنائية البعد N × M (مربعة N × N إذا كانت M تساوي None) بآحاد على القطر k وأصفار في غير ذلك.

numpy.frombuffer(buffer: bytes, *, dtype: int = float, count: int = -1, offset: int = 0) → ndarray

تفسير كائن يدعم بروتوكول المخزن المؤقت على أنه ndarray أحادية البعد من dtype. count هو عدد العناصر المراد قراءتها (-1 يقرأ كل العناصر المتاحة)؛ ويتخطى offset ذلك العدد من البايتات في بداية المخزن المؤقت.

numpy.full(shape: int | tuple[int, ...], fill_value: int | float | bool, *, dtype: int = float) → ndarray

إرجاع مصفوفة جديدة من shape وdtype مع تعيين كل عنصر إلى fill_value.

numpy.linspace(start: float, stop: float, num: int = 50, *, endpoint: bool = True, retstep: bool = False, dtype: int = float) → ndarray | tuple[ndarray, float]

إرجاع num عينة متباعدة بالتساوي على امتداد الفترة المغلقة [start, stop] (أو نصف المفتوحة إذا كانت endpoint تساوي False). عندما تكون retstep تساوي True، أرجع صفاً (samples, step). وتنتج قيم start/stop المركبة مصفوفة مركبة (عند تفعيل دعم الأعداد المركبة).

numpy.logspace(start: float, stop: float, num: int = 50, *, base: float = 10.0, endpoint: bool = True, dtype: int = float) → ndarray

إرجاع num عينة متباعدة بالتساوي على مقياس لوغاريتمي: تبدأ النتيجة عند base ** start وتنتهي عند base ** stop.

numpy.meshgrid(*xi: ndarray, indexing: str = 'xy') → tuple[ndarray, ...]

إرجاع صفّ من مصفوفات الإحداثيات من تسلسل من مصفوفات الإحداثيات أحادية البعد. مع indexing 'xy' (الافتراضي) يُعامل أول مدخلين كإحداثيات ديكارتية وتُبدَّل محاور خرجهما؛ ومع 'ij' تُستخدم الفهرسة على نمط المصفوفات. ويقابل التنفيذ المكافئ في NumPy مع copy=True وsparse=False.

numpy.ones(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray

إرجاع مصفوفة جديدة من shape وdtype معبأة بالآحاد.

numpy.zeros(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray

إرجاع مصفوفة جديدة من shape وdtype معبأة بالأصفار.

الفحص / الطباعة

numpy.get_printoptions() → dict

إرجاع خيارات طباعة المصفوفة الحالية على شكل قاموس بالمفتاحين threshold وedgeitems.

numpy.set_printoptions(*, threshold: int | None = None, edgeitems: int | None = None) → None

تعيين خيارات طباعة المصفوفة. threshold هو الحد الأقصى لعدد عناصر المصفوفة المطبوعة بالكامل؛ وedgeitems هو عدد العناصر المعروضة عند كل طرف من المحور عند تلخيص المصفوفة.

numpy.ndinfo(array: ndarray) → None

طباعة معلومات تشخيصية (الشكل، والخطوات، وdtype، وحجم العنصر، ...) حول array.

numpy.size(a: ndarray, *, axis: int | None = None) → int

إرجاع عدد عناصر a على امتداد axis؛ وإذا كانت axis تساوي None، فأرجع العدد الإجمالي للعناصر (حاصل ضرب ndarray.shape).

المقارنة

numpy.clip(a: ndarray | int | float, a_min: ndarray | int | float, a_max: ndarray | int | float) → ndarray | int | float

حصر قيم a بحيث a_min <= result <= a_max. يكافئ maximum(a_min, minimum(a, a_max))؛ ويتبع البث القواعد نفسها كما في minimum.

numpy.equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool

x1 == x2 على مستوى العناصر؛ يُرجع ndarray منطقية (أو قيمة قياسية bool إذا كان كلا المدخلين قيمتين قياسيتين). متوفرة لأغراض قابلية النقل -- يعطي العامل == على المصفوفات النتيجة نفسها.

numpy.not_equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool

x1 != x2 على مستوى العناصر؛ النظير المنطقي لـ equal.

numpy.isfinite(x: ndarray | int | float) → ndarray | bool

إرجاع مصفوفة منطقية (أو قيمة قياسية) تكون True حيث يكون الإدخال منتهياً. والمدخلات الصحيحة منتهية دائماً.

numpy.isinf(x: ndarray | int | float) → ndarray | bool

إرجاع مصفوفة منطقية (أو قيمة قياسية) تكون True حيث يكون الإدخال لا نهائياً. والمدخلات الصحيحة لا تكون لا نهائية أبداً.

numpy.maximum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float

العنصر الأكبر على مستوى العناصر لمصفوفتين / قيمتين قياسيتين. يجري بث الوسائط معاً؛ وإذا اختلفت أنواع dtype، يُرقّى الخرج.

numpy.minimum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float

العنصر الأصغر على مستوى العناصر لمصفوفتين / قيمتين قياسيتين؛ نظير maximum.

numpy.nonzero(a: ndarray) → tuple[ndarray, ...]

إرجاع صفّ من ndarray، واحدة لكل بُعد من a، تحتوي على فهارس العناصر غير الصفرية في a.

numpy.where(condition: ndarray | int | float, x: ndarray | int | float, y: ndarray | int | float) → ndarray

إرجاع ndarray تأتي عناصرها من x حيث تكون condition صادقة، ومن y في غير ذلك. تُبث المدخلات الثلاثة معاً؛ ويكون dtype الخرج هو الترقية النوعية لـ x وy.

الاختزالات العددية

numpy.all(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool

اختبار ما إذا كانت جميع العناصر على امتداد axis تُقيَّم إلى True. مع axis=None (الافتراضي) تُختبر المصفوفة المسطحة وتُرجع قيمة bool وحيدة.

numpy.any(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool

اختبار ما إذا كان أي عنصر على امتداد axis يُقيَّم إلى True. مع axis=None تُختبر المصفوفة المسطحة.

numpy.argmax(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int

إرجاع فهرس العنصر الأكبر على امتداد axis. مع axis=None تُسطَّح المصفوفة ويُرجع عدد صحيح وحيد.

numpy.argmin(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int

إرجاع فهرس العنصر الأصغر على امتداد axis. مع axis=None تُسطَّح المصفوفة ويُرجع عدد صحيح وحيد.

numpy.argsort(a: ndarray, *, axis: int = -1) → ndarray

إرجاع ndarray فهرس بأعداد صحيحة غير مؤشرة تفرز إدخالاتها a تصاعدياً على امتداد axis. وdtype الخرج هو uint16، لذلك لا يجوز أن يتجاوز أي محور 65535 عنصراً. والقيمة axis=None غير مدعومة.

numpy.cross(a: ndarray, b: ndarray) → ndarray

إرجاع الضرب الاتجاهي لمصفوفتين أحاديتي البعد بطول 3.

numpy.diff(a: ndarray, *, n: int = 1, axis: int = -1) → ndarray

إرجاع الفرق الأمامي المنفصل من الرتبة n لـ a على امتداد axis. يجب أن تكون n في المدى 0..9 (يُخزَّن قالب التفاضل في int8)؛ ويتقلص طول axis بمقدار n. والكلمتان المفتاحيتان prepend وappend في numpy غير منفذتين.

numpy.flip(a: ndarray, *, axis: int | None = None) → ndarray

إرجاع مصفوفة جديدة بترتيب عناصر معكوس على امتداد axis؛ ومع axis=None تُعكس المصفوفة على امتداد كل محور.

numpy.max(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float

إرجاع العنصر الأكبر على امتداد axis. مع axis=None (الافتراضي) تُختزل المصفوفة المسطحة إلى قيمة قياسية. والكلمة المفتاحية out في numpy غير منفذة.

numpy.min(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float

إرجاع العنصر الأصغر على امتداد axis؛ نظير max.

numpy.mean(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | float

إرجاع المتوسط الحسابي على امتداد axis. مع axis=None (الافتراضي) يُرجع متوسط المصفوفة المسطحة على شكل float.

numpy.median(a: ndarray, *, axis: int | None = None) → ndarray | float

إرجاع الوسيط على امتداد axis. مع axis=None تُسطَّح المصفوفة أولاً. وdtype الخرج هو float دائماً.

numpy.roll(a: ndarray, shift: int, *, axis: int | None = None) → ndarray

إرجاع a مع تدوير عناصرها (إزاحة دورية) بمقدار shift موضع. مع axis=None (الافتراضي) تُسطَّح المصفوفة أولاً. وتدوّر الإزاحات السالبة في الاتجاه المعاكس.

numpy.sort(a: ndarray, *, axis: int = -1) → ndarray

إرجاع نسخة مفروزة من a على امتداد axis باستخدام فرز الكومة. مع axis=None تُسطَّح المصفوفة أولاً. والكلمتان المفتاحيتان kind وorder في numpy غير منفذتين.

numpy.std(a: ndarray | list | tuple, *, axis: int | None = None, ddof: int = 0, keepdims: bool = False) → ndarray | float

إرجاع الانحراف المعياري على امتداد axis. ddof هي درجات الحرية المفروقة -- والمقسوم عليه المستخدم هو N - ddof.

numpy.sum(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float

إرجاع المجموع على امتداد axis. مع axis=None يُرجع مجموع المصفوفة المسطحة على شكل قيمة قياسية.

الإحصاءات

numpy.bincount(x: ndarray, *, weights: ndarray | None = None, minlength: int | None = None) → ndarray

عد عدد مرات ظهور كل قيمة في المصفوفة x الصحيحة غير السالبة أحادية البعد. يجب أن يكون dtype الخاص بـ x هو uint8 أو uint16. إذا أُعطيت weights، يساهم كل إدخال من x بوزنه المطابق بدلاً من 1 ويكون الخرج من نوع dtype float؛ وإلا يكون الخرج من نوع dtype uint16. وإذا أُعطيت minlength، تحتوي مصفوفة الخرج على ذلك العدد من العناصر على الأقل (الإدخالات الإضافية تكون أصفاراً).

numpy.trace(m: ndarray) → int | float

إرجاع مجموع عناصر القطر للمصفوفة المربعة m. ويتبع نوع الإرجاع dtype الخاص بـ m (تنتج المصفوفات الصحيحة عدداً صحيحاً، والمصفوفات العشرية عدداً عشرياً).

التحويل

numpy.compress(condition: ndarray | list | tuple, a: ndarray, *, axis: int | None = None) → ndarray

إرجاع شرائح من a منتقاة على امتداد axis بواسطة condition المنطقية. مع axis=None تُستخدم المصفوفة المسطحة.

numpy.delete(a: ndarray, indices: int | ndarray | list | tuple | range, *, axis: int | None = None) → ndarray

إرجاع نسخة من a مع إزالة الإدخالات عند indices على امتداد axis. مع axis=None تُسطَّح المصفوفة أولاً. وتُحسب الفهارس السالبة من نهاية axis؛ وتُفرز indices داخلياً قبل الحذف.

numpy.dot(m1: ndarray, m2: ndarray) → ndarray | float

إرجاع الضرب النقطي لمصفوفتين. بالنسبة لمصفوفتين أحاديتي البعد يكون هذا الضرب الداخلي (قيمة قياسية float). وبالنسبة للمصفوفات ثنائية البعد يكون هذا ضرب المصفوفات؛ ويجب أن تتطابق الأبعاد الداخلية. والنتيجة دائماً من نوع dtype float.

التقريب

numpy.interp(x: ndarray, xp: ndarray, fp: ndarray, *, left: float | None = None, right: float | None = None) → ndarray

استيفاء خطي أحادي البعد. يجب أن تكون xp مصفوفة أحادية البعد متزايدة بشكل رتيب من القيم المستقلة؛ وتحتوي fp على القيم التابعة المقابلة؛ وx هي النقاط التي يُقيَّم عندها المُستوفى. وتتجاوز left وright القيمة المُرجعة لـ x < xp[0] وx > xp[-1] على التوالي (القيم الافتراضية: fp[0] وfp[-1]).

numpy.trapz(y: ndarray, x: ndarray | None = None, dx: float = 1.0) → float

تكامل y باستخدام قاعدة شبه المنحرف المركّبة. إذا أُعطيت x فهي توفر مواضع العينات المقابلة لـ y؛ وإلا يُستخدم التباعد dx. ويجب أن تكون y (وx) أحادية البعد.

الانتقاء

numpy.take(a: ndarray, indices: ndarray | list | tuple, *, axis: int | None = None, out: ndarray | None = None, mode: str | None = None) → ndarray

أخذ عناصر من a عند indices المعطاة على امتداد axis. مع axis=None تُستخدم المصفوفة المسطحة. وتنتقي mode سلوك تجاوز الحدود: "raise" (الافتراضي -- إطلاق ValueError)، أو "wrap" (باقي القسمة على طول المحور)، أو "clip" (الحصر ضمن المدى الصالح؛ الفهارس السالبة غير مسموح بها). وإذا أُعطيت out تُكتب النتيجة فيها.

على مستوى البتات

numpy.bitwise_and(x1: ndarray, x2: ndarray) → ndarray

عملية AND على مستوى البتات وعلى مستوى العناصر لمصفوفتين صحيحتين؛ والبث مدعوم. ويُطلق نوع dtype غير صحيح استثناءً.

numpy.bitwise_or(x1: ndarray, x2: ndarray) → ndarray

عملية OR على مستوى البتات وعلى مستوى العناصر لمصفوفتين صحيحتين.

numpy.bitwise_xor(x1: ndarray, x2: ndarray) → ndarray

عملية XOR على مستوى البتات وعلى مستوى العناصر لمصفوفتين صحيحتين.

numpy.left_shift(x1: ndarray, x2: ndarray) → ndarray

إزاحة على مستوى البتات وعلى مستوى العناصر لـ x1 نحو اليسار بمقدار x2 بت؛ ويجب أن يكون لكلتا المصفوفتين dtype صحيح.

numpy.right_shift(x1: ndarray, x2: ndarray) → ndarray

إزاحة على مستوى البتات وعلى مستوى العناصر لـ x1 نحو اليمين بمقدار x2 بت؛ ويجب أن يكون لكلتا المصفوفتين dtype صحيح.

الترشيح

numpy.convolve(a: ndarray, v: ndarray) → ndarray

إرجاع الالتفاف الخطي المنفصل لمصفوفتين أحاديتي البعد. ويُدعم وضع "full" فقط؛ والكلمة المفتاحية mode في numpy غير مقبولة (يمكن الحصول على الأوضاع الأخرى بتقطيع النتيجة الكاملة). وطول الخرج هو len(a) + len(v) - 1.

كثير الحدود

numpy.polyfit(x: ndarray | list | tuple, y: ndarray | list | tuple, deg: int) → ndarray

numpy.polyfit(y: ndarray | list | tuple, deg: int) → ndarray

ملاءمة كثير حدود من الدرجة deg لنقاط البيانات (x, y) بطريقة المربعات الصغرى وإرجاع معاملات كثير الحدود (الدرجة الأعلى أولاً). إذا حُذفت x، تُستخدم range(len(y)). ويُطلق ValueError إذا اختلف طولا x وy.

numpy.polyval(p: ndarray | list | tuple, x: ndarray | list | tuple | int | float) → ndarray | float

تقييم كثير الحدود الذي معاملاته p (الدرجة الأعلى أولاً) عند x. إذا كانت x قيمة قياسية يُرجع float، وإلا تُرجع ndarray.

الإدخال/الإخراج

numpy.load(file: str) → ndarray

قراءة مصفوفة كُتبت سابقاً بواسطة save من file (تنسيق .npy المستقل عن النظام الأساسي الخاص بـ numpy). ويُحوَّل ترتيب البايتات أثناء التشغيل إذا اختلف ترتيب بايتات الملف عن ترتيب المضيف.

numpy.loadtxt(file: str, *, delimiter: str | None = None, comments: str = '#', max_rows: int = -1, usecols: int | ndarray | list | tuple | None = None, dtype: int = float, skiprows: int = 0) → ndarray

قراءة بيانات عددية من ملف نصي file وإرجاعها على شكل ndarray. القيمة الافتراضية لـ delimiter هي المسافة البيضاء؛ وcomments هو علامة تعليق السطر؛ ويحد max_rows من عدد صفوف البيانات المقروءة (-1 للكل)؛ وتنتقي usecols الأعمدة بالفهرس؛ ويتخطى skiprows ذلك العدد من الصفوف الأولى. وإذا لم تكن dtype عشرية، تُحوَّل القيم بالتقريب.

numpy.save(file: str, a: ndarray) → None

حفظ a في file بتنسيق .npy المستقل عن النظام الأساسي الخاص بـ numpy.

numpy.savetxt(file: str, a: ndarray, *, delimiter: str = ' ', header: str | None = None, footer: str | None = None, comments: str = '# ') → None

كتابة a في file كنص. يفصل delimiter القيم ضمن الصف؛ وتُكتب header وfooter، إذا أُعطيتا، قبل/بعد البيانات، كل منها مسبوقة بـ comments. وتُكتب القيم كأعداد عشرية بفاصلة عائمة.

مساعدات الأعداد المركبة

تتوفر هذه الدوال فقط عندما تُجمَّع ulab مع دعم الأعداد المركبة (ULAB_SUPPORTS_COMPLEX).

numpy.real(val: ndarray) → ndarray

إرجاع الجزء الحقيقي من val. بالنسبة لإدخال من نوع dtype حقيقي، يُرجع نسخة تحافظ على dtype؛ وبالنسبة لإدخال مركب، يُرجع ndarray عشرية.

numpy.imag(val: ndarray) → ndarray

إرجاع الجزء التخيلي من val. بالنسبة لإدخال من نوع dtype حقيقي، يُرجع مصفوفة أصفار بنفس dtype؛ وبالنسبة لإدخال مركب، يُرجع ndarray عشرية.

numpy.conjugate(val: ndarray | complex | int | float) → ndarray | complex | int | float

إرجاع المرافق المركب لـ val. وتُرجع المدخلات ذات القيم الحقيقية دون تغيير.

numpy.sort_complex(a: ndarray) → ndarray

فرز المصفوفة أحادية البعد a أولاً حسب الجزء الحقيقي، ثم حسب الجزء التخيلي. والنتيجة دائماً من نوع dtype مركب، حتى لو كانت a ذات قيمة حقيقية.

الدوال الشاملة

دوال رياضية على مستوى العناصر. تقبل كل منها قيمة قياسية أو ndarray وتُرجع نتيجة بشكل مطابق (قيمة قياسية عشرية لإدخال قياسي، وndarray لإدخال مصفوفة). عند الاستدعاء بـ ndarray، تكون النتيجة ndarray عشرية جديدة بفاصلة عائمة؛ ويمكن تمرير كلمة مفتاحية اختيارية out لكتابة النتيجة في ndarray عشرية مخصصة مسبقاً بنفس الحجم.

numpy.acos(x: ndarray | float, /) → ndarray | float

حساب جيب التمام العكسي (قوس جيب التمام) لكل عنصر من x؛ والنتيجة بالراديان.

numpy.acosh(x: ndarray | float, /) → ndarray | float

حساب جيب التمام الزائدي العكسي لكل عنصر من x.

numpy.arctan2(y: ndarray | float, x: ndarray | float, /) → ndarray | float

حساب الظل العكسي ذي الوسيطين atan2(y, x) على مستوى العناصر؛ ويدعم البث بين المدخلين.

numpy.around(x: ndarray, /, decimals: int = 0) → ndarray

تقريب عناصر الـ ndarray x إلى العدد المعطى من decimals؛ ويجب أن يكون الوسيط الأول ndarray.

numpy.asin(x: ndarray | float, /) → ndarray | float

حساب الجيب العكسي (قوس الجيب) لكل عنصر من x؛ والنتيجة بالراديان.

numpy.asinh(x: ndarray | float, /) → ndarray | float

حساب الجيب الزائدي العكسي لكل عنصر من x.

numpy.atan(x: ndarray | float, /) → ndarray | float

حساب الظل العكسي (قوس الظل) لكل عنصر من x؛ والنتيجة بالراديان.

numpy.atanh(x: ndarray | float, /) → ndarray | float

حساب الظل الزائدي العكسي لكل عنصر من x.

numpy.ceil(x: ndarray | float, /) → ndarray | float

حساب السقف (أصغر عدد صحيح ليس أقل من القيمة) لكل عنصر من x.

numpy.cos(x: ndarray | float, /) → ndarray | float

حساب جيب التمام لكل عنصر من x (بالراديان).

numpy.cosh(x: ndarray | float, /) → ndarray | float

حساب جيب التمام الزائدي لكل عنصر من x.

numpy.degrees(x: ndarray | float, /) → ndarray | float

تحويل كل عنصر من x من الراديان إلى الدرجات.

numpy.exp(x: ndarray | float, /) → ndarray | float

حساب الدالة الأسية e**x لكل عنصر من x؛ وقد يُرجع ndarray مركبة عند إعطائه إدخالاً مركباً (إذا كان دعم الأعداد المركبة مفعّلاً).

numpy.expm1(x: ndarray | float, /) → ndarray | float

حساب exp(x) - 1 لكل عنصر من x بدقة محسّنة قرب الصفر.

numpy.floor(x: ndarray | float, /) → ndarray | float

حساب الأرضية (أكبر عدد صحيح ليس أكبر من القيمة) لكل عنصر من x.

numpy.log(x: ndarray | float, /) → ndarray | float

حساب اللوغاريتم الطبيعي لكل عنصر من x.

numpy.log10(x: ndarray | float, /) → ndarray | float

حساب اللوغاريتم للأساس 10 لكل عنصر من x.

numpy.log2(x: ndarray | float, /) → ndarray | float

حساب اللوغاريتم للأساس 2 لكل عنصر من x.

numpy.radians(x: ndarray | float, /) → ndarray | float

تحويل كل عنصر من x من الدرجات إلى الراديان.

numpy.sin(x: ndarray | float, /) → ndarray | float

حساب الجيب لكل عنصر من x (بالراديان).

numpy.sinc(x: ndarray | float, /) → ndarray | float

حساب دالة sinc المعيارية sin(pi*x) / (pi*x) لكل عنصر من x.

numpy.sinh(x: ndarray | float, /) → ndarray | float

حساب الجيب الزائدي لكل عنصر من x.

numpy.sqrt(x: ndarray | float, /, *, dtype: int = float) → ndarray | float

حساب الجذر التربيعي لكل عنصر من x؛ مرر dtype=numpy.complex للحصول على نتائج مركبة للمدخلات الحقيقية السالبة (إذا كان دعم الأعداد المركبة مفعّلاً).

numpy.tan(x: ndarray | float, /) → ndarray | float

حساب الظل لكل عنصر من x (بالراديان).

numpy.tanh(x: ndarray | float, /) → ndarray | float

حساب الظل الزائدي لكل عنصر من x.

numpy.vectorize(f: Callable[[float], float], /, *, otypes: int | None = None) → Callable

إرجاع كائن قابل للاستدعاء يطبق دالة بايثون f على مستوى العناصر على قيمة قياسية أو عنصر قابل للتكرار أو ndarray؛ وتنتقي otypes نوع dtype للخرج (الافتراضي float).

الثوابت

numpy.e: float

عدد أويلر \(e \approx 2.71828\).

numpy.pi: float

\(\pi \approx 3.14159\).

numpy.inf: float

اللانهاية الموجبة بفاصلة عائمة وفق IEEE-754.

numpy.nan: float

"ليس عدداً" بفاصلة عائمة وفق IEEE-754.

numpy.bool: int

رمز dtype للمصفوفات المنطقية (تُخزَّن كـ uint8).

numpy.uint8: int

رمز dtype لمصفوفات الأعداد الصحيحة غير المؤشرة بحجم 8 بت.

numpy.int8: int

رمز dtype لمصفوفات الأعداد الصحيحة المؤشرة بحجم 8 بت.

numpy.uint16: int

رمز dtype لمصفوفات الأعداد الصحيحة غير المؤشرة بحجم 16 بت.

numpy.int16: int

رمز dtype لمصفوفات الأعداد الصحيحة المؤشرة بحجم 16 بت.

numpy.float: int

رمز dtype للمصفوفات ذات الفاصلة العائمة بحجم 32 بت.