Linear Algebra

NoPivot

لا يتم تنفيذ التدوير. قد تفشل عمليات تحليل المصفوفات مثل تحليل LU بدون تدوير، وقد تكون أيضًا غير مستقرة عدديًا لمصفوفات النقطة العائمة في مواجهة أخطاء التقريب. هذه الاستراتيجية للتدوير مفيدة بشكل أساسي لأغراض تعليمية.

RowNonZero

يتم اختيار أول عنصر غير صفري في الصفوف المتبقية كعنصر محوري.

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

لاحظ أن نوع العنصر للمصفوفة يجب أن يقبل طريقة iszero.

RowMaximum

يتم اختيار العنصر ذو القيمة المطلقة القصوى في الصفوف المتبقية كعنصر محوري. هذه هي الاستراتيجية الافتراضية لتحليل LU لمصفوفات الأعداد العشرية، وأحيانًا يُشار إليها باسم خوارزمية "التحويل الجزئي".

لاحظ أن نوع العنصر للمصفوفة يجب أن يقبل طريقة abs، ويجب أن يقبل نوع النتيجة طريقة <.

ColumnNorm

يتم استخدام العمود الذي يحتوي على أكبر معيار للحسابات اللاحقة. يتم استخدام ذلك لتفكيك QR المحوري.

لاحظ أن نوع العنصر للمصفوفة يجب أن يقبل طرق norm و abs ، ويجب أن تقبل أنواع النتائج الخاصة بها طريقة <.

*(A::AbstractMatrix, B::AbstractMatrix)

ضرب المصفوفات.

أمثلة

julia> [1 1; 0 1] * [1 0; 1 1]
2×2 Matrix{Int64}:
 2  1
 1  1

*(A, B::AbstractMatrix, C)
A * B * C * D

يتم تنفيذ الضرب المتسلسل لـ 3 أو 4 مصفوفات بأكثر تسلسل كفاءة، بناءً على أحجام المصفوفات. أي، يتم مقارنة عدد الضربات العددية اللازمة لـ (A * B) * C (مع 3 مصفوفات كثيفة) مع تلك لـ A * (B * C) لاختيار أي من هذه العمليات يتم تنفيذها.

إذا كان العامل الأخير متجهًا، أو الأول متجهًا مُعكوسًا، فمن الكفء التعامل مع هذه أولاً. على وجه الخصوص، x' * B * y تعني (x' * B) * y لمصفوفة عادية ذات ترتيب عمودي B::Matrix. على عكس dot(x, B, y)، فإن هذا يخصص مصفوفة وسيطة.

إذا كان العامل الأول أو الأخير عددًا، فسيتم دمجه مع ضرب المصفوفات، باستخدام 5-arg mul!.

انظر أيضًا muladd، dot.

\(A, B)

قسمة المصفوفات باستخدام خوارزمية متعددة. بالنسبة لمصفوفتين المدخلات A و B، تكون النتيجة X بحيث A*X == B عندما تكون A مربعة. يعتمد الحل المستخدم على هيكل A. إذا كانت A مثلثية علوية أو سفلية (أو قطرية)، فلا حاجة لتفكيك A ويتم حل النظام إما باستخدام الاستبدال الأمامي أو الخلفي. بالنسبة للمصفوفات المربعة غير المثلثية، يتم استخدام تفكيك LU.

بالنسبة لـ A المستطيلة، تكون النتيجة هي الحل الأدنى للمعايير المربعة المحسوبة بواسطة تفكيك QR مع التدوير وتقدير الرتبة لـ A بناءً على عامل R.

عندما تكون A متفرقة، يتم استخدام خوارزمية متعددة مماثلة. بالنسبة للمصفوفات غير المحددة، لا يستخدم تفكيك LDLt التدوير أثناء التفكيك العددي وبالتالي قد تفشل العملية حتى بالنسبة للمصفوفات القابلة للعكس.

انظر أيضًا: factorize، pinv.

أمثلة

julia> A = [1 0; 1 -2]; B = [32; -4];

julia> X = A \ B
2-element Vector{Float64}:
 32.0
 18.0

julia> A * X == B
true

A / B

تقسيم المصفوفات من اليمين: A / B يعادل (B' \ A')' حيث \ هو عامل القسمة من اليسار. بالنسبة للمصفوفات المربعة، النتيجة X هي بحيث A == X*B.

انظر أيضًا: rdiv!.

أمثلة

julia> A = Float64[1 4 5; 3 9 2]; B = Float64[1 4 2; 3 4 2; 8 7 1];

julia> X = A / B
2×3 Matrix{Float64}:
 -0.65   3.75  -1.2
  3.25  -2.75   1.0

julia> isapprox(A, X*B)
true

julia> isapprox(X, A*pinv(B))
true

استثناء فردي

يتم طرح استثناء عندما تحتوي مصفوفة الإدخال على قيمة واحدة أو أكثر من القيم الذاتية صفرية، ولا يمكن عكسها. لا يمكن حساب حل خطي يتضمن مثل هذه المصفوفة. يشير حقل info إلى موقع (واحد من) القيم الفردية.

استثناء PosDefException

يتم طرح استثناء عندما لا تكون مصفوفة الإدخال موجبة محددة. بعض دوال الجبر الخطي والتحليل العوامل تنطبق فقط على المصفوفات الموجبة المحددة. يشير حقل info إلى موقع (واحد من) القيم الذاتية التي هي (أو) أقل من/تساوي 0.

ZeroPivotException <: Exception

استثناء يُرمى عندما تواجه عملية تحليل/حل مصفوفة صفرًا في موضع محور (قطري) ولا يمكنها المتابعة. قد لا يعني ذلك أن المصفوفة غير قابلة للعكس: قد يكون من المفيد الانتقال إلى تحليل مختلف مثل LU المعاد ترتيبها الذي يمكن أن يعيد ترتيب المتغيرات لإزالة المحاور الصفرية الزائفة. يشير حقل info إلى موقع (واحد من) المحاور الصفرية.

RankDeficientException

استثناء يُرمى عندما تكون المصفوفة المدخلة ناقصة الرتبة. بعض دوال الجبر الخطي، مثل تحليل شولسكي، تنطبق فقط على المصفوفات التي ليست ناقصة الرتبة. يشير حقل info إلى الرتبة المحسوبة للمصفوفة.

LAPACKException

استثناء عام من LAPACK يتم رميه إما أثناء المكالمات المباشرة إلى وظائف LAPACK أو أثناء المكالمات إلى وظائف أخرى تستخدم وظائف LAPACK داخليًا ولكن تفتقر إلى معالجة الأخطاء المتخصصة. يحتوي حقل info على معلومات إضافية حول الخطأ الأساسي ويعتمد على وظيفة LAPACK التي تم استدعاؤها.

dot(x, y)
x ⋅ y

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

dot يعمل أيضًا على كائنات قابلة للتكرار بشكل عشوائي، بما في ذلك المصفوفات من أي بعد، طالما أن dot معرف على العناصر.

dot يعادل دلاليًا sum(dot(vx,vy) for (vx,vy) in zip(x, y))، مع القيد الإضافي بأن المعطيات يجب أن تكون لها أطوال متساوية.

x ⋅ y (حيث يمكن كتابة ⋅ عن طريق إكمال التبويب \cdot في REPL) هو مرادف لـ dot(x, y).

أمثلة

julia> dot([1; 1], [2; 3])
5

julia> dot([im; im], [1; 1])
0 - 2im

julia> dot(1:5, 2:6)
70

julia> x = fill(2., (5,5));

julia> y = fill(3., (5,5));

julia> dot(x, y)
150.0

dot(x, A, y)

احسب ناتج الضرب النقطي العام dot(x, A*y) بين متجهين x و y، دون تخزين النتيجة الوسيطة لـ A*y. كما هو الحال في dot(_,_) ذو المعاملين، فإن هذا يعمل بشكل تكراري. علاوة على ذلك، بالنسبة للمتجهات المعقدة، يتم أخذ المرافق للمتجه الأول.

أمثلة

julia> dot([1; 1], [1 2; 3 4], [2; 3])
26

julia> dot(1:5, reshape(1:25, 5, 5), 2:6)
4850

julia> ⋅(1:5, reshape(1:25, 5, 5), 2:6) == dot(1:5, reshape(1:25, 5, 5), 2:6)
true

cross(x, y)
×(x,y)

احسب حاصل الضرب المتقاطع لثلاثي متجهات.

أمثلة

julia> a = [0;1;0]
3-element Vector{Int64}:
 0
 1
 0

julia> b = [0;0;1]
3-element Vector{Int64}:
 0
 0
 1

julia> cross(a,b)
3-element Vector{Int64}:
 1
 0
 0

axpy!(α, x::AbstractArray, y::AbstractArray)

استبدل y بـ x * α + y وأعد y. إذا كانت لـ x و y نفس المحاور، فإنها تعادل y .+= x .* a.

أمثلة

julia> x = [1; 2; 3];

julia> y = [4; 5; 6];

julia> axpy!(2, x, y)
3-element Vector{Int64}:
  6
  9
 12

axpby!(α, x::AbstractArray, β, y::AbstractArray)

استبدل y بـ x * α + y * β وأعد y. إذا كانت لـ x و y نفس المحاور، فإنها تعادل y .= x .* a .+ y .* β.

أمثلة

julia> x = [1; 2; 3];

julia> y = [4; 5; 6];

julia> axpby!(2, x, 2, y)
3-element Vector{Int64}:
 10
 14
 18

rotate!(x, y, c, s)

استبدل x بـ c*x + s*y و y بـ -conj(s)*x + c*y. يُرجع x و y.

reflect!(x, y, c, s)

استبدل x بـ c*x + s*y و y بـ conj(s)*x - c*y. يُرجع x و y.

factorize(A)

احسب تحليلًا مناسبًا لـ A، بناءً على نوع مصفوفة الإدخال. تتحقق factorize من A لترى ما إذا كانت متماثلة/مثلثية/إلخ إذا تم تمرير A كمصفوفة عامة. تتحقق factorize من كل عنصر في A للتحقق من كل خاصية أو استبعادها. ستتوقف عن العمل بمجرد أن تتمكن من استبعاد التماثل/الهيكل المثلثي. يمكن إعادة استخدام قيمة الإرجاع لحل أنظمة متعددة بكفاءة. على سبيل المثال: A=factorize(A); x=A\b; y=A\C.

إذا تم استدعاء factorize على مصفوفة هيرميتية إيجابية التعريف، على سبيل المثال، فإن factorize ستعيد تحليل شولي.

أمثلة

julia> A = Array(Bidiagonal(fill(1.0, (5, 5)), :U))
5×5 Matrix{Float64}:
 1.0  1.0  0.0  0.0  0.0
 0.0  1.0  1.0  0.0  0.0
 0.0  0.0  1.0  1.0  0.0
 0.0  0.0  0.0  1.0  1.0
 0.0  0.0  0.0  0.0  1.0

julia> factorize(A) # factorize ستتحقق لترى أن A قد تم تحليلها بالفعل
5×5 Bidiagonal{Float64, Vector{Float64}}:
 1.0  1.0   ⋅    ⋅    ⋅
  ⋅   1.0  1.0   ⋅    ⋅
  ⋅    ⋅   1.0  1.0   ⋅
  ⋅    ⋅    ⋅   1.0  1.0
  ⋅    ⋅    ⋅    ⋅   1.0

هذا يعيد 5×5 Bidiagonal{Float64}، والتي يمكن الآن تمريرها إلى وظائف الجبر الخطي الأخرى (مثل محللات القيم الذاتية) التي ستستخدم طرق متخصصة لأنواع Bidiagonal.

Diagonal(V::AbstractVector)

قم بإنشاء مصفوفة كسولة مع V كقطرها.

انظر أيضًا UniformScaling لمصفوفة الهوية الكسولة I، وdiagm لإنشاء مصفوفة كثيفة، وdiag لاستخراج العناصر القطرية.

أمثلة

julia> d = Diagonal([1, 10, 100])
3×3 Diagonal{Int64, Vector{Int64}}:
 1   ⋅    ⋅
 ⋅  10    ⋅
 ⋅   ⋅  100

julia> diagm([7, 13])
2×2 Matrix{Int64}:
 7   0
 0  13

julia> ans + I
2×2 Matrix{Int64}:
 8   0
 0  14

julia> I(2)
2×2 Diagonal{Bool, Vector{Bool}}:
 1  ⋅
 ⋅  1

!!! ملاحظة لا تُعتبر المصفوفة ذات العمود الواحد مثل المتجه، بل تستدعي الطريقة Diagonal(A::AbstractMatrix) التي تستخرج diag(A) ذات العنصر الواحد:

julia> A = transpose([7.0 13.0])
2×1 transpose(::Matrix{Float64}) with eltype Float64:
  7.0
 13.0

julia> Diagonal(A)
1×1 Diagonal{Float64, Vector{Float64}}:
 7.0

Diagonal(A::AbstractMatrix)

قم بإنشاء مصفوفة من القطر الرئيسي لـ A. قد تكون المصفوفة المدخلة A مستطيلة، لكن الناتج سيكون مربعًا.

أمثلة

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> D = Diagonal(A)
2×2 Diagonal{Int64, Vector{Int64}}:
 1  ⋅
 ⋅  4

julia> A = [1 2 3; 4 5 6]
2×3 Matrix{Int64}:
 1  2  3
 4  5  6

julia> Diagonal(A)
2×2 Diagonal{Int64, Vector{Int64}}:
 1  ⋅
 ⋅  5

Diagonal{T}(undef, n)

قم بإنشاء Diagonal{T} غير مُهيأ بطول n. انظر undef.

Bidiagonal(dv::V, ev::V, uplo::Symbol) where V <: AbstractVector

ينشئ مصفوفة ثنائية القطر (bidiagonal) علوية (uplo=:U) أو سفلية (uplo=:L) باستخدام القطر المعطى (dv) والقطر الجانبي (ev). النتيجة من نوع Bidiagonal وتوفر حلول خطية متخصصة بكفاءة، ولكن يمكن تحويلها إلى مصفوفة عادية باستخدام convert(Array, _) (أو Array(_) باختصار). يجب أن يكون طول ev أقل بواحد من طول dv.

أمثلة

julia> dv = [1, 2, 3, 4]
4-element Vector{Int64}:
 1
 2
 3
 4

julia> ev = [7, 8, 9]
3-element Vector{Int64}:
 7
 8
 9

julia> Bu = Bidiagonal(dv, ev, :U) # ev على القطر الفائق الأول
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  7  ⋅  ⋅
 ⋅  2  8  ⋅
 ⋅  ⋅  3  9
 ⋅  ⋅  ⋅  4

julia> Bl = Bidiagonal(dv, ev, :L) # ev على القطر السفلي الأول
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  ⋅  ⋅  ⋅
 7  2  ⋅  ⋅
 ⋅  8  3  ⋅
 ⋅  ⋅  9  4

Bidiagonal(A, uplo::Symbol)

قم بإنشاء مصفوفة Bidiagonal من القطر الرئيسي لـ A وأول فوق القطر (إذا كان uplo=:U) أو تحت القطر (إذا كان uplo=:L).

أمثلة

julia> A = [1 1 1 1; 2 2 2 2; 3 3 3 3; 4 4 4 4]
4×4 Matrix{Int64}:
 1  1  1  1
 2  2  2  2
 3  3  3  3
 4  4  4  4

julia> Bidiagonal(A, :U) # تحتوي على القطر الرئيسي وأول فوق القطر لـ A
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  1  ⋅  ⋅
 ⋅  2  2  ⋅
 ⋅  ⋅  3  3
 ⋅  ⋅  ⋅  4

julia> Bidiagonal(A, :L) # تحتوي على القطر الرئيسي وأول تحت القطر لـ A
4×4 Bidiagonal{Int64, Vector{Int64}}:
 1  ⋅  ⋅  ⋅
 2  2  ⋅  ⋅
 ⋅  3  3  ⋅
 ⋅  ⋅  4  4

SymTridiagonal(dv::V, ev::V) where V <: AbstractVector

قم بإنشاء مصفوفة ثلاثية القطر متناظرة من القطر (dv) والأقطار الفرعية/الفوقية الأولى (ev) على التوالي. النتيجة من نوع SymTridiagonal وتوفر حلول خاصة فعالة للقيم الذاتية، ولكن يمكن تحويلها إلى مصفوفة عادية باستخدام convert(Array, _) (أو Array(_) للاختصار).

بالنسبة لمصفوفات الكتل SymTridiagonal، يتم تنسيق عناصر dv. يتم تفسير الوسيط ev كقطر فوقي. الكتل من القطر الفرعي هي (مادة) نقل للكتل المقابلة من القطر الفوقي.

أمثلة

julia> dv = [1, 2, 3, 4]
4-element Vector{Int64}:
 1
 2
 3
 4

julia> ev = [7, 8, 9]
3-element Vector{Int64}:
 7
 8
 9

julia> SymTridiagonal(dv, ev)
4×4 SymTridiagonal{Int64, Vector{Int64}}:
 1  7  ⋅  ⋅
 7  2  8  ⋅
 ⋅  8  3  9
 ⋅  ⋅  9  4

julia> A = SymTridiagonal(fill([1 2; 3 4], 3), fill([1 2; 3 4], 2));

julia> A[1,1]
2×2 Symmetric{Int64, Matrix{Int64}}:
 1  2
 2  4

julia> A[1,2]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> A[2,1]
2×2 Matrix{Int64}:
 1  3
 2  4

SymTridiagonal(A::AbstractMatrix)

قم بإنشاء مصفوفة ثلاثية القطر متناظرة من القطر والأول فوق القطر للمصفوفة المتناظرة A.

أمثلة

julia> A = [1 2 3; 2 4 5; 3 5 6]
3×3 Matrix{Int64}:
 1  2  3
 2  4  5
 3  5  6

julia> SymTridiagonal(A)
3×3 SymTridiagonal{Int64, Vector{Int64}}:
 1  2  ⋅
 2  4  5
 ⋅  5  6

julia> B = reshape([[1 2; 2 3], [1 2; 3 4], [1 3; 2 4], [1 2; 2 3]], 2, 2);

julia> SymTridiagonal(B)
2×2 SymTridiagonal{Matrix{Int64}, Vector{Matrix{Int64}}}:
 [1 2; 2 3]  [1 3; 2 4]
 [1 2; 3 4]  [1 2; 2 3]

Tridiagonal(dl::V, d::V, du::V) where V <: AbstractVector

قم بإنشاء مصفوفة ثلاثية القطر من القطر الفرعي الأول، القطر الرئيسي، والقطر الفائق الأول، على التوالي. النتيجة من نوع Tridiagonal وتوفر حلول خطية متخصصة بكفاءة، ولكن يمكن تحويلها إلى مصفوفة عادية باستخدام convert(Array, _) (أو Array(_) باختصار). يجب أن تكون أطوال dl و du أقل بواحد من طول d.

!!! ملاحظة يجب ألا يكون القطر الفرعي dl والقطر الفائق du متطابقين. إذا تم اكتشاف التطابق، سيستخدم المُنشئ نسخة من du كوسيط له.

أمثلة

julia> dl = [1, 2, 3];

julia> du = [4, 5, 6];

julia> d = [7, 8, 9, 0];

julia> Tridiagonal(dl, d, du)
4×4 Tridiagonal{Int64, Vector{Int64}}:
 7  4  ⋅  ⋅
 1  8  5  ⋅
 ⋅  2  9  6
 ⋅  ⋅  3  0

Tridiagonal(A)

قم بإنشاء مصفوفة ثلاثية القطر من أول تحت القطر، القطر، وأول فوق القطر من المصفوفة A.

أمثلة

julia> A = [1 2 3 4; 1 2 3 4; 1 2 3 4; 1 2 3 4]
4×4 Matrix{Int64}:
 1  2  3  4
 1  2  3  4
 1  2  3  4
 1  2  3  4

julia> Tridiagonal(A)
4×4 Tridiagonal{Int64, Vector{Int64}}:
 1  2  ⋅  ⋅
 1  2  3  ⋅
 ⋅  2  3  4
 ⋅  ⋅  3  4

Symmetric(A::AbstractMatrix, uplo::Symbol=:U)

قم بإنشاء عرض Symmetric للجزء العلوي (إذا كان uplo = :U) أو الجزء السفلي (إذا كان uplo = :L) من المصفوفة A.

تكون عروض Symmetric مفيدة بشكل أساسي للمصفوفات الحقيقية المتماثلة، والتي يتم تمكين خوارزميات متخصصة لها (مثل تلك الخاصة بمشاكل القيم الذاتية) لأنواع Symmetric. بشكل عام، انظر أيضًا إلى Hermitian(A) للمصفوفات المتماثلة A == A'، والتي تعادل فعليًا Symmetric للمصفوفات الحقيقية ولكنها مفيدة أيضًا للمصفوفات المعقدة. (بينما يتم دعم المصفوفات المعقدة Symmetric ولكن لديها القليل من الخوارزميات المتخصصة إن وجدت.)

لحساب الجزء المتماثل من مصفوفة حقيقية، أو بشكل أكثر عمومية الجزء المتماثل (A + A') / 2 من مصفوفة حقيقية أو معقدة A، استخدم hermitianpart.

أمثلة

julia> A = [1 2 3; 4 5 6; 7 8 9]
3×3 Matrix{Int64}:
 1  2  3
 4  5  6
 7  8  9

julia> Supper = Symmetric(A)
3×3 Symmetric{Int64, Matrix{Int64}}:
 1  2  3
 2  5  6
 3  6  9

julia> Slower = Symmetric(A, :L)
3×3 Symmetric{Int64, Matrix{Int64}}:
 1  4  7
 4  5  8
 7  8  9

julia> hermitianpart(A)
3×3 Hermitian{Float64, Matrix{Float64}}:
 1.0  3.0  5.0
 3.0  5.0  7.0
 5.0  7.0  9.0

لاحظ أن Supper لن تكون مساوية لـ Slower ما لم تكن A نفسها متماثلة (على سبيل المثال، إذا كانت A == transpose(A)).

Hermitian(A::AbstractMatrix, uplo::Symbol=:U)

قم بإنشاء عرض Hermitian للجزء العلوي (إذا كان uplo = :U) أو الجزء السفلي (إذا كان uplo = :L) من المصفوفة A.

لحساب الجزء الهيرميتي من A، استخدم hermitianpart.

أمثلة

julia> A = [1 2+2im 3-3im; 4 5 6-6im; 7 8+8im 9]
3×3 Matrix{Complex{Int64}}:
 1+0im  2+2im  3-3im
 4+0im  5+0im  6-6im
 7+0im  8+8im  9+0im

julia> Hupper = Hermitian(A)
3×3 Hermitian{Complex{Int64}, Matrix{Complex{Int64}}}:
 1+0im  2+2im  3-3im
 2-2im  5+0im  6-6im
 3+3im  6+6im  9+0im

julia> Hlower = Hermitian(A, :L)
3×3 Hermitian{Complex{Int64}, Matrix{Complex{Int64}}}:
 1+0im  4+0im  7+0im
 4+0im  5+0im  8-8im
 7+0im  8+8im  9+0im

julia> hermitianpart(A)
3×3 Hermitian{ComplexF64, Matrix{ComplexF64}}:
 1.0+0.0im  3.0+1.0im  5.0-1.5im
 3.0-1.0im  5.0+0.0im  7.0-7.0im
 5.0+1.5im  7.0+7.0im  9.0+0.0im

لاحظ أن Hupper لن يكون مساوياً لـ Hlower ما لم تكن A نفسها هيرميتي (على سبيل المثال، إذا كانت A == adjoint(A)).

سيتم تجاهل جميع الأجزاء غير الحقيقية من القطر.

Hermitian(fill(complex(1,1), 1, 1)) == fill(1, 1, 1)

LowerTriangular(A::AbstractMatrix)

قم بإنشاء عرض LowerTriangular للمصفوفة A.

أمثلة

julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
3×3 Matrix{Float64}:
 1.0  2.0  3.0
 4.0  5.0  6.0
 7.0  8.0  9.0

julia> LowerTriangular(A)
3×3 LowerTriangular{Float64, Matrix{Float64}}:
 1.0   ⋅    ⋅
 4.0  5.0   ⋅
 7.0  8.0  9.0

UpperTriangular(A::AbstractMatrix)

قم بإنشاء عرض UpperTriangular للمصفوفة A.

أمثلة

julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
3×3 Matrix{Float64}:
 1.0  2.0  3.0
 4.0  5.0  6.0
 7.0  8.0  9.0

julia> UpperTriangular(A)
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 1.0  2.0  3.0
  ⋅   5.0  6.0
  ⋅    ⋅   9.0

UnitLowerTriangular(A::AbstractMatrix)

قم بإنشاء عرض UnitLowerTriangular للمصفوفة A. يحتوي هذا العرض على oneunit من eltype لـ A على قطره.

أمثلة

julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
3×3 Matrix{Float64}:
 1.0  2.0  3.0
 4.0  5.0  6.0
 7.0  8.0  9.0

julia> UnitLowerTriangular(A)
3×3 UnitLowerTriangular{Float64, Matrix{Float64}}:
 1.0   ⋅    ⋅
 4.0  1.0   ⋅
 7.0  8.0  1.0

UnitUpperTriangular(A::AbstractMatrix)

قم بإنشاء عرض UnitUpperTriangular للمصفوفة A. يحتوي هذا العرض على oneunit من eltype لـ A على قطره.

أمثلة

julia> A = [1.0 2.0 3.0; 4.0 5.0 6.0; 7.0 8.0 9.0]
3×3 Matrix{Float64}:
 1.0  2.0  3.0
 4.0  5.0  6.0
 7.0  8.0  9.0

julia> UnitUpperTriangular(A)
3×3 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  2.0  3.0
  ⋅   1.0  6.0
  ⋅    ⋅   1.0

UpperHessenberg(A::AbstractMatrix)

قم بإنشاء عرض UpperHessenberg للمصفوفة A. يتم تجاهل العناصر في A أسفل القطر الفرعي الأول.

تم تنفيذ خوارزميات فعالة لـ H \ b و det(H) وما شابه.

انظر أيضًا إلى دالة hessenberg لتحليل أي مصفوفة إلى مصفوفة علوية هيسنبرغ مماثلة.

إذا كان F::Hessenberg هو كائن التحليل، يمكن الوصول إلى المصفوفة الوحدوية باستخدام F.Q ومصفوفة هيسنبرغ باستخدام F.H. عند استخراج Q، يكون النوع الناتج هو كائن HessenbergQ، ويمكن تحويله إلى مصفوفة عادية باستخدام convert(Array, _) (أو Array(_) باختصار).

يؤدي تكرار التحليل إلى إنتاج العوامل F.Q و F.H.

أمثلة

julia> A = [1 2 3 4; 5 6 7 8; 9 10 11 12; 13 14 15 16]
4×4 Matrix{Int64}:
  1   2   3   4
  5   6   7   8
  9  10  11  12
 13  14  15  16

julia> UpperHessenberg(A)
4×4 UpperHessenberg{Int64, Matrix{Int64}}:
 1   2   3   4
 5   6   7   8
 ⋅  10  11  12
 ⋅   ⋅  15  16

UniformScaling{T<:Number}

عامل التحجيم الموحد بحجم عام معرف كعدد مضروب في عامل الهوية، λ*I. على الرغم من عدم وجود size صريح، فإنه يعمل بشكل مشابه لمصفوفة في العديد من الحالات ويشمل دعمًا لبعض الفهرسة. انظر أيضًا I.

أمثلة

julia> J = UniformScaling(2.)
UniformScaling{Float64}
2.0*I

julia> A = [1. 2.; 3. 4.]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> J*A
2×2 Matrix{Float64}:
 2.0  4.0
 6.0  8.0

julia> J[1:2, 1:2]
2×2 Matrix{Float64}:
 2.0  0.0
 0.0  2.0

I

كائن من النوع UniformScaling، يمثل مصفوفة هوية بأي حجم.

أمثلة

julia> fill(1, (5,6)) * I == fill(1, (5,6))
true

julia> [1 2im 3; 1im 2 3] * I
2×3 Matrix{Complex{Int64}}:
 1+0im  0+2im  3+0im
 0+1im  2+0im  3+0im

(I::UniformScaling)(n::Integer)

قم بإنشاء مصفوفة Diagonal من UniformScaling.

أمثلة

julia> I(3)
3×3 Diagonal{Bool, Vector{Bool}}:
 1  ⋅  ⋅
 ⋅  1  ⋅
 ⋅  ⋅  1

julia> (0.7*I)(3)
3×3 Diagonal{Float64, Vector{Float64}}:
 0.7   ⋅    ⋅
  ⋅   0.7   ⋅
  ⋅    ⋅   0.7

LinearAlgebra.Factorization

نوع تجريدي لـ تحليل المصفوفات المعروف أيضًا باسم تحلل المصفوفات. راجع التوثيق عبر الإنترنت للحصول على قائمة بتحليلات المصفوفات المتاحة.

LU <: Factorization

نوع تحليل المصفوفات لتحليل LU لمصفوفة مربعة A. هذا هو نوع الإرجاع لـ lu، دالة تحليل المصفوفات المقابلة.

يمكن الوصول إلى المكونات الفردية للتحليل F::LU عبر getproperty:

يؤدي تكرار التحليل إلى إنتاج المكونات F.L و F.U و F.p.

أمثلة

julia> A = [4 3; 6 3]
2×2 Matrix{Int64}:
 4  3
 6  3

julia> F = lu(A)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
2×2 Matrix{Float64}:
 1.0       0.0
 0.666667  1.0
U factor:
2×2 Matrix{Float64}:
 6.0  3.0
 0.0  1.0

julia> F.L * F.U == A[F.p, :]
true

julia> l, u, p = lu(A); # تدمير عبر التكرار

julia> l == F.L && u == F.U && p == F.p
true

lu(A::AbstractSparseMatrixCSC; check = true, q = nothing, control = get_umfpack_control()) -> F::UmfpackLU

احسب تحليل LU لمصفوفة متفرقة A.

بالنسبة لـ A المتفرقة مع نوع عنصر حقيقي أو مركب، نوع الإرجاع لـ F هو UmfpackLU{Tv, Ti}، حيث Tv = Float64 أو ComplexF64 على التوالي و Ti هو نوع صحيح (Int32 أو Int64).

عندما يكون check = true، يتم إلقاء خطأ إذا فشل التحليل. عندما يكون check = false، تقع مسؤولية التحقق من صحة التحليل (عبر issuccess) على عاتق المستخدم.

يمكن أن يكون التبديل q إما متجه تبديل أو nothing. إذا لم يتم توفير متجه تبديل أو كان q هو nothing، يتم استخدام الافتراضي لـ UMFPACK. إذا لم يكن التبديل يعتمد على الصفر، يتم عمل نسخة تعتمد على الصفر.

يتضمن متجه control التكوين الافتراضي لحزمة Julia SparseArrays لـ UMFPACK (ملاحظة: تم تعديل هذا من الافتراضيات لـ UMFPACK لتعطيل التحسين التكراري)، ولكن يمكن تغييره عن طريق تمرير متجه بطول UMFPACK_CONTROL، انظر دليل UMFPACK للتكوينات الممكنة. على سبيل المثال لإعادة تمكين التحسين التكراري:

umfpack_control = SparseArrays.UMFPACK.get_umfpack_control(Float64, Int64) # قراءة التكوين الافتراضي لجوليا لمصفوفة متفرقة من نوع Float64
SparseArrays.UMFPACK.show_umf_ctrl(umfpack_control) # اختياري - عرض القيم
umfpack_control[SparseArrays.UMFPACK.JL_UMFPACK_IRSTEP] = 2.0 # إعادة تمكين التحسين التكراري (2 هو الحد الأقصى الافتراضي لخطوات التحسين التكراري لـ UMFPACK)

Alu = lu(A; control = umfpack_control)
x = Alu \ b   # حل Ax = b، بما في ذلك التحسين التكراري لـ UMFPACK

يمكن الوصول إلى المكونات الفردية للتحليل F عن طريق الفهرسة:

العلاقة بين F و A هي

F.L*F.U == (F.Rs .* A)[F.p, F.q]

يدعم F أيضًا الوظائف التالية:

• \
• det

انظر أيضًا lu!

!!! ملاحظة lu(A::AbstractSparseMatrixCSC) يستخدم مكتبة UMFPACK^[ACM832] التي هي جزء من SuiteSparse. حيث أن هذه المكتبة تدعم فقط المصفوفات المتفرقة مع عناصر Float64 أو ComplexF64، يقوم lu بتحويل A إلى نسخة من النوع SparseMatrixCSC{Float64} أو SparseMatrixCSC{ComplexF64} حسب الاقتضاء.

lu(A, pivot = RowMaximum(); check = true, allowsingular = false) -> F::LU

احسب تحليل LU لـ A.

عندما يكون check = true، يتم إلقاء خطأ إذا فشلت التحليل. عندما يكون check = false، تقع مسؤولية التحقق من صحة التحليل (عبر issuccess) على عاتق المستخدم.

بشكل افتراضي، مع check = true، يتم أيضًا إلقاء خطأ عندما ينتج التحليل عوامل صالحة، ولكن العامل العلوي المثلث U يعاني من نقص في الرتبة. يمكن تغيير ذلك عن طريق تمرير allowsingular = true.

في معظم الحالات، إذا كانت A نوعًا فرعيًا S من AbstractMatrix{T} مع نوع عنصر T يدعم + و - و * و /، فإن نوع الإرجاع هو LU{T,S{T}}.

بشكل عام، يتضمن تحليل LU تبديل صفوف المصفوفة (الذي يتوافق مع مخرجات F.p الموضحة أدناه)، والمعروف باسم "التحويل" (لأنه يتوافق مع اختيار الصف الذي يحتوي على "التحويل"، المدخل القطري لـ F.U). يمكن اختيار واحدة من استراتيجيات التحويل التالية عبر وسيط pivot الاختياري:

• RowMaximum() (افتراضي): استراتيجية التحويل القياسية؛ يتوافق التحويل مع العنصر الذي له أكبر قيمة مطلقة بين الصفوف المتبقية التي سيتم تحليلها. تتطلب هذه الاستراتيجية أن يدعم نوع العنصر أيضًا abs و <. (هذه هي الخيار الوحيد المستقر عدديًا لمصفوفات النقاط العائمة بشكل عام.)
• RowNonZero(): يتوافق التحويل مع أول عنصر غير صفري بين الصفوف المتبقية التي سيتم تحليلها. (هذا يتوافق مع الاختيار النموذجي في الحسابات اليدوية، وهو مفيد أيضًا لأنواع الأعداد الجبرية الأكثر عمومية التي تدعم iszero ولكن ليس abs أو <.)
• NoPivot(): تم إيقاف التحويل (سيفشل إذا تم مواجهة إدخال صفري في موضع التحويل، حتى عندما يكون allowsingular = true).

يمكن الوصول إلى المكونات الفردية للتحليل F عبر getproperty:

يؤدي تكرار التحليل إلى إنتاج المكونات F.L و F.U و F.p.

العلاقة بين F و A هي

F.L*F.U == A[F.p, :]

يدعم F أيضًا الوظائف التالية:

أمثلة

julia> A = [4 3; 6 3]
2×2 Matrix{Int64}:
 4  3
 6  3

julia> F = lu(A)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
2×2 Matrix{Float64}:
 1.0       0.0
 0.666667  1.0
U factor:
2×2 Matrix{Float64}:
 6.0  3.0
 0.0  1.0

julia> F.L * F.U == A[F.p, :]
true

julia> l, u, p = lu(A); # تفكيك عبر التكرار

julia> l == F.L && u == F.U && p == F.p
true

julia> lu([1 2; 1 2], allowsingular = true)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
2×2 Matrix{Float64}:
 1.0  0.0
 1.0  1.0
U factor (rank-deficient):
2×2 Matrix{Float64}:
 1.0  2.0
 0.0  0.0

lu!(F::UmfpackLU, A::AbstractSparseMatrixCSC; check=true, reuse_symbolic=true, q=nothing) -> F::UmfpackLU

احسب تحليل LU لمصفوفة متفرقة A، مع إعادة استخدام التحليل الرمزي لتحليل LU موجود مسبقًا مخزن في F. ما لم يتم تعيين reuse_symbolic إلى false، يجب أن تحتوي المصفوفة المتفرقة A على نمط غير صفري مطابق للمصفوفة المستخدمة لإنشاء تحليل LU F، وإلا سيتم إلقاء خطأ. إذا اختلف حجم A و F، سيتم تغيير حجم جميع المتجهات وفقًا لذلك.

عندما يكون check = true، سيتم إلقاء خطأ إذا فشل التحليل. عندما يكون check = false، تقع مسؤولية التحقق من صحة التحليل (عبر issuccess) على عاتق المستخدم.

يمكن أن تكون التبديلة q إما متجه تبديل أو nothing. إذا لم يتم توفير متجه تبديل أو كان q هو nothing، يتم استخدام الافتراضي لـ UMFPACK. إذا لم يكن التبديل قائمًا على الصفر، يتم عمل نسخة قائمة على الصفر.

انظر أيضًا lu

أمثلة

julia> A = sparse(Float64[1.0 2.0; 0.0 3.0]);

julia> F = lu(A);

julia> B = sparse(Float64[1.0 1.0; 0.0 1.0]);

julia> lu!(F, B);

julia> F \ ones(2)
2-element Vector{Float64}:
 0.0
 1.0

lu!(A, pivot = RowMaximum(); check = true, allowsingular = false) -> LU

lu! هو نفسه lu، ولكنه يوفر المساحة عن طريق الكتابة فوق المدخل A، بدلاً من إنشاء نسخة. يتم رمي استثناء InexactError إذا كانت التحليل ينتج عنه رقم لا يمكن تمثيله بواسطة نوع عنصر A، على سبيل المثال، لأنواع الأعداد الصحيحة.

أمثلة

julia> A = [4. 3.; 6. 3.]
2×2 Matrix{Float64}:
 4.0  3.0
 6.0  3.0

julia> F = lu!(A)
LU{Float64, Matrix{Float64}, Vector{Int64}}
L factor:
2×2 Matrix{Float64}:
 1.0       0.0
 0.666667  1.0
U factor:
2×2 Matrix{Float64}:
 6.0  3.0
 0.0  1.0

julia> iA = [4 3; 6 3]
2×2 Matrix{Int64}:
 4  3
 6  3

julia> lu!(iA)
ERROR: InexactError: Int64(0.6666666666666666)
Stacktrace:
[...]

Cholesky <: Factorization

نوع تحليل المصفوفات لتحليل شولي (Cholesky) لمصفوفة متراصة/هرميتية إيجابية محددة كثيفة A. هذا هو نوع الإرجاع لـ cholesky، دالة تحليل المصفوفات المقابلة.

يمكن الحصول على عامل شولي المثلث من التحليل F::Cholesky عبر F.L و F.U، حيث A ≈ F.U' * F.U ≈ F.L * F.L'.

تتوفر الوظائف التالية لكائنات Cholesky: size، \، inv، det، logdet و isposdef.

يؤدي تكرار التحليل إلى إنتاج المكونات L و U.

أمثلة

julia> A = [4. 12. -16.; 12. 37. -43.; -16. -43. 98.]
3×3 Matrix{Float64}:
   4.0   12.0  -16.0
  12.0   37.0  -43.0
 -16.0  -43.0   98.0

julia> C = cholesky(A)
Cholesky{Float64, Matrix{Float64}}
U factor:
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 2.0  6.0  -8.0
  ⋅   1.0   5.0
  ⋅    ⋅    3.0

julia> C.U
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 2.0  6.0  -8.0
  ⋅   1.0   5.0
  ⋅    ⋅    3.0

julia> C.L
3×3 LowerTriangular{Float64, Matrix{Float64}}:
  2.0   ⋅    ⋅
  6.0  1.0   ⋅
 -8.0  5.0  3.0

julia> C.L * C.U == A
true

julia> l, u = C; # destructuring via iteration

julia> l == C.L && u == C.U
true

CholeskyPivoted

نوع تحليل المصفوفة لتحليل شولي المباشر الموجه لمصفوفة متراصة متناسقة/هرميتية إيجابية شبه محددة A. هذا هو نوع الإرجاع لـ cholesky(_, ::RowMaximum)، وظيفة تحليل المصفوفة المقابلة.

يمكن الحصول على عامل شولي المثلث من التحليل F::CholeskyPivoted عبر F.L و F.U، والترتيب عبر F.p، حيث A[F.p, F.p] ≈ Ur' * Ur ≈ Lr * Lr' مع Ur = F.U[1:F.rank, :] و Lr = F.L[:, 1:F.rank]، أو بدلاً من ذلك A ≈ Up' * Up ≈ Lp * Lp' مع Up = F.U[1:F.rank, invperm(F.p)] و Lp = F.L[invperm(F.p), 1:F.rank].

الوظائف التالية متاحة لكائنات CholeskyPivoted: size، \، inv، det، و rank.

تنتج عملية التكرار في التحليل المكونات L و U.

أمثلة

julia> X = [1.0, 2.0, 3.0, 4.0];

julia> A = X * X';

julia> C = cholesky(A, RowMaximum(), check = false)
CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}
U factor with rank 1:
4×4 UpperTriangular{Float64, Matrix{Float64}}:
 4.0  2.0  3.0  1.0
  ⋅   0.0  6.0  2.0
  ⋅    ⋅   9.0  3.0
  ⋅    ⋅    ⋅   1.0
permutation:
4-element Vector{Int64}:
 4
 2
 3
 1

julia> C.U[1:C.rank, :]' * C.U[1:C.rank, :] ≈ A[C.p, C.p]
true

julia> l, u = C; # destructuring via iteration

julia> l == C.L && u == C.U
true

cholesky(A, NoPivot(); check = true) -> Cholesky

احسب تحليل شولي (Cholesky) لمصفوفة كثيفة متناظرة موجبة محددة A وأعد Cholesky كتحليل. يمكن أن تكون المصفوفة A إما Symmetric أو Hermitian AbstractMatrix أو مصفوفة AbstractMatrix متناظرة أو هيرميتية تمامًا.

يمكن الحصول على عامل شولي المثلثي من التحليل F عبر F.L و F.U، حيث A ≈ F.U' * F.U ≈ F.L * F.L'.

تتوفر الوظائف التالية لأجسام Cholesky: size، \، inv، det، logdet و isposdef.

إذا كان لديك مصفوفة A غير هيرميتية قليلاً بسبب أخطاء التقريب في إنشائها، قم بلفها في Hermitian(A) قبل تمريرها إلى cholesky لمعالجتها كهرميتية تمامًا.

عندما يكون check = true، يتم إلقاء خطأ إذا فشلت التحليل. عندما يكون check = false، تقع مسؤولية التحقق من صحة التحليل (عبر issuccess) على عاتق المستخدم.

أمثلة

julia> A = [4. 12. -16.; 12. 37. -43.; -16. -43. 98.]
3×3 Matrix{Float64}:
   4.0   12.0  -16.0
  12.0   37.0  -43.0
 -16.0  -43.0   98.0

julia> C = cholesky(A)
Cholesky{Float64, Matrix{Float64}}
U factor:
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 2.0  6.0  -8.0
  ⋅   1.0   5.0
  ⋅    ⋅    3.0

julia> C.U
3×3 UpperTriangular{Float64, Matrix{Float64}}:
 2.0  6.0  -8.0
  ⋅   1.0   5.0
  ⋅    ⋅    3.0

julia> C.L
3×3 LowerTriangular{Float64, Matrix{Float64}}:
  2.0   ⋅    ⋅
  6.0  1.0   ⋅
 -8.0  5.0  3.0

julia> C.L * C.U == A
true

cholesky(A, RowMaximum(); tol = 0.0, check = true) -> CholeskyPivoted

احسب التحليل العوامل شوليكي المدعوم لمصفوفة كثيفة متناظرة إيجابية شبه محددة A وأعد CholeskyPivoted التحليل. يمكن أن تكون المصفوفة A إما Symmetric أو Hermitian AbstractMatrix أو مصفوفة AbstractMatrix متناظرة أو هيرميتية تمامًا.

يمكن الحصول على عامل شوليكي المثلث من التحليل F عبر F.L و F.U، والتبديل عبر F.p، حيث A[F.p, F.p] ≈ Ur' * Ur ≈ Lr * Lr' مع Ur = F.U[1:F.rank, :] و Lr = F.L[:, 1:F.rank]، أو بدلاً من ذلك A ≈ Up' * Up ≈ Lp * Lp' مع Up = F.U[1:F.rank, invperm(F.p)] و Lp = F.L[invperm(F.p), 1:F.rank].

الوظائف التالية متاحة لكائنات CholeskyPivoted: size، \، inv، det، و rank.

تحدد المعلمة tol التسامح لتحديد الرتبة. بالنسبة للقيم السلبية، يكون التسامح هو دقة الآلة.

إذا كان لديك مصفوفة A غير هيرميتية قليلاً بسبب أخطاء التقريب في إنشائها، قم بلفها في Hermitian(A) قبل تمريرها إلى cholesky من أجل التعامل معها على أنها هيرميتية تمامًا.

عندما يكون check = true، يتم طرح خطأ إذا فشل التحليل. عندما يكون check = false، تقع مسؤولية التحقق من صحة التحليل (عبر issuccess) على عاتق المستخدم.

أمثلة

julia> X = [1.0, 2.0, 3.0, 4.0];

julia> A = X * X';

julia> C = cholesky(A, RowMaximum(), check = false)
CholeskyPivoted{Float64, Matrix{Float64}, Vector{Int64}}
U factor with rank 1:
4×4 UpperTriangular{Float64, Matrix{Float64}}:
 4.0  2.0  3.0  1.0
  ⋅   0.0  6.0  2.0
  ⋅    ⋅   9.0  3.0
  ⋅    ⋅    ⋅   1.0
permutation:
4-element Vector{Int64}:
 4
 2
 3
 1

julia> C.U[1:C.rank, :]' * C.U[1:C.rank, :] ≈ A[C.p, C.p]
true

julia> l, u = C; # destructuring via iteration

julia> l == C.L && u == C.U
true

cholesky(A::SparseMatrixCSC; shift = 0.0, check = true, perm = nothing) -> CHOLMOD.Factor

احسب تحليل شولي (Cholesky) لمصفوفة متفرقة موجبة محددة A. يجب أن تكون A إما SparseMatrixCSC أو عرض Symmetric/Hermitian لمصفوفة SparseMatrixCSC. لاحظ أنه حتى إذا لم يكن لـ A علامة نوع، يجب أن تكون متماثلة أو هيرميتية. إذا لم يتم إعطاء perm، يتم استخدام ترتيب يقلل من التعبئة. F = cholesky(A) هو الأكثر استخدامًا لحل أنظمة المعادلات باستخدام F\b، ولكن أيضًا يتم تعريف الطرق diag، det، وlogdet لـ F. يمكنك أيضًا استخراج عوامل فردية من F، باستخدام F.L. ومع ذلك، نظرًا لأن التدوير مفعل بشكل افتراضي، يتم تمثيل التحليل داخليًا كـ A == P'*L*L'*P مع مصفوفة ترتيب P؛ استخدام L فقط دون مراعاة P سيعطي إجابات غير صحيحة. لتضمين تأثيرات الترتيب، من المفضل عادةً استخراج "عوامل مجمعة" مثل PtL = F.PtL (ما يعادل P'*L) و LtP = F.UP (ما يعادل L'*P).

عندما يكون check = true، يتم إلقاء خطأ إذا فشل التحليل. عندما يكون check = false، تقع مسؤولية التحقق من صحة التحليل (عبر issuccess) على عاتق المستخدم.

تعيين وسيط الكلمة الاختياري shift يحسب التحليل لـ A+shift*I بدلاً من A. إذا تم توفير وسيط perm، يجب أن يكون ترتيبًا لـ 1:size(A,1) يعطي الترتيب الذي يجب استخدامه (بدلاً من ترتيب AMD الافتراضي لـ CHOLMOD).

أمثلة

في المثال التالي، يتم استخدام ترتيب يقلل من التعبئة وهو [3, 2, 1]. إذا تم تعيين perm إلى 1:3 لفرض عدم وجود ترتيب، فإن عدد العناصر غير الصفرية في العامل هو 6.

julia> A = [2 1 1; 1 2 0; 1 0 2]
3×3 Matrix{Int64}:
 2  1  1
 1  2  0
 1  0  2

julia> C = cholesky(sparse(A))
SparseArrays.CHOLMOD.Factor{Float64, Int64}
type:    LLt
method:  simplicial
maxnnz:  5
nnz:     5
success: true

julia> C.p
3-element Vector{Int64}:
 3
 2
 1

julia> L = sparse(C.L);

julia> Matrix(L)
3×3 Matrix{Float64}:
 1.41421   0.0       0.0
 0.0       1.41421   0.0
 0.707107  0.707107  1.0

julia> L * L' ≈ A[C.p, C.p]
true

julia> P = sparse(1:3, C.p, ones(3))
3×3 SparseMatrixCSC{Float64, Int64} with 3 stored entries:
  ⋅    ⋅   1.0
  ⋅   1.0   ⋅
 1.0   ⋅    ⋅

julia> P' * L * L' * P ≈ A
true

julia> C = cholesky(sparse(A), perm=1:3)
SparseArrays.CHOLMOD.Factor{Float64, Int64}
type:    LLt
method:  simplicial
maxnnz:  6
nnz:     6
success: true

julia> L = sparse(C.L);

julia> Matrix(L)
3×3 Matrix{Float64}:
 1.41421    0.0       0.0
 0.707107   1.22474   0.0
 0.707107  -0.408248  1.1547

julia> L * L' ≈ A
true

!!! ملاحظة تستخدم هذه الطريقة مكتبة CHOLMOD^{[ACM887][DavisHager2009]} من SuiteSparse. تدعم CHOLMOD فقط الأنواع الحقيقية أو المعقدة بدقة مفردة أو مزدوجة. سيتم تحويل مصفوفات الإدخال التي ليست من تلك الأنواع إلى هذه الأنواع حسب الاقتضاء.

يتم لف العديد من الوظائف الأخرى من CHOLMOD ولكنها ليست مصدرة من وحدة `Base.SparseArrays.CHOLMOD`.

cholesky!(A::AbstractMatrix, NoPivot(); check = true) -> Cholesky

نفس الشيء كما في cholesky، ولكن يوفر المساحة عن طريق الكتابة فوق المدخل A، بدلاً من إنشاء نسخة. يتم رمي استثناء InexactError إذا كانت التحليل ينتج عددًا لا يمكن تمثيله بواسطة نوع عنصر A، على سبيل المثال، لأنواع الأعداد الصحيحة.

أمثلة

julia> A = [1 2; 2 50]
2×2 Matrix{Int64}:
 1   2
 2  50

julia> cholesky!(A)
ERROR: InexactError: Int64(6.782329983125268)
Stacktrace:
[...]

cholesky!(A::AbstractMatrix, RowMaximum(); tol = 0.0, check = true) -> CholeskyPivoted

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

cholesky!(F::CHOLMOD.Factor, A::SparseMatrixCSC; shift = 0.0, check = true) -> CHOLMOD.Factor

احسب تحليل شولي ( $LL'$ ) لعامل A، مع إعادة استخدام التحليل الرمزي F. يجب أن تكون A عبارة عن SparseMatrixCSC أو عرض Symmetric/ Hermitian لـ SparseMatrixCSC. لاحظ أنه حتى إذا لم يكن لـ A علامة نوع، يجب أن تظل متماثلة أو هيرميتية.

انظر أيضًا cholesky.

!!! ملاحظة تستخدم هذه الطريقة مكتبة CHOLMOD من SuiteSparse، التي تدعم فقط الأنواع الحقيقية أو المعقدة بدقة مفردة أو مزدوجة. سيتم تحويل المصفوفات المدخلة التي ليست من تلك الأنواع العنصرية إلى هذه الأنواع حسب الاقتضاء.

lowrankupdate(C::Cholesky, v::AbstractVector) -> CC::Cholesky

تحديث تحليل شولي C مع المتجه v. إذا كان A = C.U'C.U فإن CC = cholesky(C.U'C.U + v*v') ولكن حساب CC يستخدم فقط O(n^2) عمليات.

lowrankupdate(F::CHOLMOD.Factor, C::AbstractArray) -> FF::CHOLMOD.Factor

احصل على تحليل LDLt لـ A + C*C' معطى تحليل LDLt أو LLt لـ F من A.

العامل المعاد هو دائمًا تحليل LDLt.

انظر أيضًا lowrankupdate!, lowrankdowndate, lowrankdowndate!.

lowrankdowndate(C::Cholesky, v::AbstractVector) -> CC::Cholesky

تحديث منخفض الرتبة لتحليل شولي C باستخدام المتجه v. إذا كان A = C.U'C.U فإن CC = cholesky(C.U'C.U - v*v') ولكن حساب CC يستخدم فقط O(n^2) عمليات.

lowrankdowndate(F::CHOLMOD.Factor, C::AbstractArray) -> FF::CHOLMOD.Factor

احصل على تحليل LDLt لـ A + C*C' معطى تحليل LDLt أو LLt لـ F من A.

العامل المعاد هو دائمًا تحليل LDLt.

انظر أيضًا lowrankdowndate!, lowrankupdate, lowrankupdate!.

lowrankupdate!(C::Cholesky, v::AbstractVector) -> CC::Cholesky

قم بتحديث تحليل شولي C باستخدام المتجه v. إذا كان A = C.U'C.U فإن CC = cholesky(C.U'C.U + v*v') ولكن حساب CC يستخدم فقط O(n^2) عمليات. يتم تحديث تحليل الإدخال C في المكان بحيث عند الخروج C == CC. يتم تدمير المتجه v أثناء الحساب.

lowrankupdate!(F::CHOLMOD.Factor, C::AbstractArray)

تحديث LDLt أو LLt تحليل F لـ A إلى تحليل لـ A + C*C'.

يتم تحويل تحليلات LLt إلى LDLt.

انظر أيضًا lowrankupdate، lowrankdowndate، lowrankdowndate!.

lowrankdowndate!(C::Cholesky, v::AbstractVector) -> CC::Cholesky

تحديث عامل تشولسكي C باستخدام المتجه v. إذا كان A = C.U'C.U فإن CC = cholesky(C.U'C.U - v*v') ولكن حساب CC يستخدم فقط O(n^2) عمليات. يتم تحديث عامل الإدخال C في المكان بحيث عند الخروج C == CC. يتم تدمير المتجه v أثناء الحساب.

lowrankdowndate!(F::CHOLMOD.Factor, C::AbstractArray)

قم بتحديث عامل LDLt أو LLt F لـ A إلى عامل لـ A - C*C'.

يتم تحويل عوامل LLt إلى LDLt.

انظر أيضًا lowrankdowndate، lowrankupdate، lowrankupdate!.

LDLt <: Factorization

نوع تحليل المصفوفات من تحليل LDLt لمصفوفة SymTridiagonal حقيقية S بحيث S = L*Diagonal(d)*L'، حيث L هي مصفوفة UnitLowerTriangular و d هو متجه. الاستخدام الرئيسي لتحليل LDLt F = ldlt(S) هو حل نظام المعادلات الخطية Sx = b باستخدام F\b. هذا هو نوع الإرجاع من ldlt، وظيفة تحليل المصفوفات المقابلة.

يمكن الوصول إلى المكونات الفردية للتحليل F::LDLt عبر getproperty:

أمثلة

julia> S = SymTridiagonal([3., 4., 5.], [1., 2.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 3.0  1.0   ⋅
 1.0  4.0  2.0
  ⋅   2.0  5.0

julia> F = ldlt(S)
LDLt{Float64, SymTridiagonal{Float64, Vector{Float64}}}
L factor:
3×3 UnitLowerTriangular{Float64, SymTridiagonal{Float64, Vector{Float64}}}:
 1.0        ⋅         ⋅
 0.333333  1.0        ⋅
 0.0       0.545455  1.0
D factor:
3×3 Diagonal{Float64, Vector{Float64}}:
 3.0   ⋅        ⋅
  ⋅   3.66667   ⋅
  ⋅    ⋅       3.90909

ldlt(S::SymTridiagonal) -> LDLt

احسب تحليل LDLt (أي، $LDL^T$) لمصفوفة ثلاثية القطر الحقيقية المتماثلة S بحيث S = L*Diagonal(d)*L' حيث L هي مصفوفة مثلثية سفلية وحدوية و d هو متجه. الاستخدام الرئيسي لتحليل LDLt F = ldlt(S) هو حل نظام المعادلات الخطية Sx = b باستخدام F\b.

انظر أيضًا bunchkaufman لتحليل مشابه، ولكن مع التدوير، لمصفوفات متماثلة أو هيرميتية عشوائية.

أمثلة

julia> S = SymTridiagonal([3., 4., 5.], [1., 2.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 3.0  1.0   ⋅
 1.0  4.0  2.0
  ⋅   2.0  5.0

julia> ldltS = ldlt(S);

julia> b = [6., 7., 8.];

julia> ldltS \ b
3-element Vector{Float64}:
 1.7906976744186047
 0.627906976744186
 1.3488372093023255

julia> S \ b
3-element Vector{Float64}:
 1.7906976744186047
 0.627906976744186
 1.3488372093023255

ldlt(A::SparseMatrixCSC; shift = 0.0, check = true, perm=nothing) -> CHOLMOD.Factor

احسب تحليل $LDL'$ لمصفوفة متفرقة A. يجب أن تكون A إما SparseMatrixCSC أو عرض Symmetric/Hermitian لمصفوفة متفرقة SparseMatrixCSC. لاحظ أنه حتى إذا لم يكن لدى A علامة نوع، يجب أن تظل متماثلة أو هيرميتية. يتم استخدام ترتيب يقلل من التعبئة. F = ldlt(A) هو الأكثر استخدامًا لحل أنظمة المعادلات A*x = b باستخدام F\b. يدعم كائن التحليل المعاد F أيضًا الطرق diag، det، logdet، وinv. يمكنك استخراج العوامل الفردية من F باستخدام F.L. ومع ذلك، نظرًا لأن التدوير مفعل بشكل افتراضي، يتم تمثيل التحليل داخليًا كـ A == P'*L*D*L'*P مع مصفوفة ترتيب P؛ استخدام L فقط دون مراعاة P سيعطي إجابات غير صحيحة. لتضمين آثار الترتيب، من المفضل عادةً استخراج العوامل "المجمعة" مثل PtL = F.PtL (ما يعادل P'*L) و LtP = F.UP (ما يعادل L'*P). القائمة الكاملة للعوامل المدعومة هي :L, :PtL, :D, :UP, :U, :LD, :DU, :PtLD, :DUP.

عند check = true، يتم إلقاء خطأ إذا فشل التحليل. عند check = false، تقع مسؤولية التحقق من صحة التحليل (عبر issuccess) على عاتق المستخدم.

تعيين وسيط الكلمة الاختياري shift يحسب التحليل لـ A+shift*I بدلاً من A. إذا تم توفير وسيط perm، يجب أن يكون ترتيبًا لـ 1:size(A,1) يعطي الترتيب الذي يجب استخدامه (بدلاً من ترتيب AMD الافتراضي لـ CHOLMOD).

!!! ملاحظة تستخدم هذه الطريقة مكتبة CHOLMOD^{[ACM887][DavisHager2009]} من SuiteSparse. تدعم CHOLMOD فقط الأنواع الحقيقية أو المعقدة بدقة مفردة أو مزدوجة. سيتم تحويل المصفوفات المدخلة التي ليست من تلك الأنواع العنصرية إلى هذه الأنواع حسب الاقتضاء.

تم لف العديد من الوظائف الأخرى من CHOLMOD ولكن لم يتم تصديرها من وحدة `Base.SparseArrays.CHOLMOD`.

ldlt!(S::SymTridiagonal) -> LDLt

نفس الشيء كما في ldlt، ولكن يوفر المساحة عن طريق الكتابة فوق المدخل S، بدلاً من إنشاء نسخة.

أمثلة

julia> S = SymTridiagonal([3., 4., 5.], [1., 2.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 3.0  1.0   ⋅
 1.0  4.0  2.0
  ⋅   2.0  5.0

julia> ldltS = ldlt!(S);

julia> ldltS === S
false

julia> S
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 3.0       0.333333   ⋅
 0.333333  3.66667   0.545455
  ⋅        0.545455  3.90909

ldlt!(F::CHOLMOD.Factor, A::SparseMatrixCSC; shift = 0.0, check = true) -> CHOLMOD.Factor

احسب تحليل $LDL'$ لـ A، مع إعادة استخدام التحليل الرمزي F. يجب أن تكون A عبارة عن SparseMatrixCSC أو عرض Symmetric/Hermitian لـ SparseMatrixCSC. لاحظ أنه حتى لو لم يكن لـ A علامة نوع، يجب أن تظل متماثلة أو هيرميتية.

انظر أيضًا ldlt.

!!! ملاحظة تستخدم هذه الطريقة مكتبة CHOLMOD من SuiteSparse، التي تدعم فقط الأنواع الحقيقية أو المعقدة بدقة مفردة أو مزدوجة. سيتم تحويل المصفوفات المدخلة التي ليست من تلك الأنواع العنصرية إلى هذه الأنواع حسب الاقتضاء.

QR <: Factorization

تحليل مصفوفة QR مخزنة في تنسيق مضغوط، يتم الحصول عليها عادةً من qr. إذا كانت $A$ مصفوفة m×n، فإن

\[A = Q R\]

حيث $Q$ هي مصفوفة متعامدة/وحيدة وحيث $R$ مثلث علوي. يتم تخزين المصفوفة $Q$ كسلسلة من عواكس هاوسهولدر $v_i$ ومعاملات $\tau_i$ حيث:

\[Q = \prod_{i=1}^{\min(m,n)} (I - \tau_i v_i v_i^T).\]

تنتج عملية التكرار في التحليل المكونات Q و R.

يمتلك الكائن حقلين:

• factors هي مصفوفة m×n.

  • تحتوي الجزء العلوي المثلث على عناصر $R$، أي R = triu(F.factors) لكائن QR هو F.
  • تحتوي الجزء تحت القطر على العواكس $v_i$ المخزنة في تنسيق مضغوط حيث $v_i$ هو العمود $i$ من المصفوفة V = I + tril(F.factors, -1).

• τ هو متجه بطول min(m,n) يحتوي على المعاملات $au_i$.

QRCompactWY <: Factorization

تحليل مصفوفة QR مخزنة بتنسيق محجوز مضغوط، يتم الحصول عليه عادةً من qr. إذا كانت $A$ مصفوفة m×n، فإن

\[A = Q R\]

حيث $Q$ هي مصفوفة متعامدة/وحدوية و$R$ مثلث علوي. إنه مشابه لتنسيق QR باستثناء أن المصفوفة المتعامدة/الوحدوية $Q$ مخزنة بتنسيق Compact WY ^{[Schreiber1989]}. بالنسبة لحجم الكتلة $n_b$، يتم تخزينها كمصفوفة مثلثية سفلية m×n $V$ ومصفوفة $T = (T_1 \; T_2 \; ... \; T_{b-1} \; T_b')$ تتكون من $b = \lceil \min(m,n) / n_b \rceil$ مصفوفات مثلثية علوية $T_j$ بحجم $n_b$×$n_b$ ($j = 1, ..., b-1$) ومصفوفة مثلثية علوية $n_b$×$\min(m,n) - (b-1) n_b$ $T_b'$ ($j=b$) التي الجزء العلوي المربع منها يُشار إليه بـ $T_b$ بحيث

\[Q = \prod_{i=1}^{\min(m,n)} (I - \tau_i v_i v_i^T) = \prod_{j=1}^{b} (I - V_j T_j V_j^T)\]

بحيث $v_i$ هو العمود $i$ من $V$، و$\tau_i$ هو العنصر $i$ من [diag(T_1); diag(T_2); …; diag(T_b)]، و$(V_1 \; V_2 \; ... \; V_b)$ هو الكتلة اليسرى m×min(m, n) من $V$. عند إنشائها باستخدام qr، يتم إعطاء حجم الكتلة بواسطة $n_b = \min(m, n, 36)$.

تنتج عملية تكرار التحليل المكونات Q وR.

يمتلك الكائن حقلين:

• factors، كما في نوع QR، هو مصفوفة m×n.

  • تحتوي الجزء العلوي المثلثي على عناصر $R$، أي R = triu(F.factors) لكائن QR F.
  • تحتوي الجزء تحت القطر على العواكس $v_i$ المخزنة بتنسيق مضغوط بحيث V = I + tril(F.factors, -1).

• T هي مصفوفة بحجم $n_b$×$\min(m,n)$ كما هو موصوف أعلاه. يتم تجاهل العناصر تحت القطر لكل مصفوفة مثلثية $T_j$.

!!! ملاحظة يجب عدم الخلط بين هذا التنسيق وتمثيل WY الأقدم ^{[Bischof1987]}.

QRPivoted <: Factorization

تحليل مصفوفة QR مع تبديل الأعمدة في تنسيق مضغوط، يتم الحصول عليه عادةً من qr. إذا كانت $A$ مصفوفة بحجم m×n، فإن

\[A P = Q R\]

حيث $P$ هي مصفوفة تبديل، و$Q$ هي مصفوفة متعامدة/وحيدة، و$R$ هي مثلثية علوية. يتم تخزين المصفوفة $Q$ كسلسلة من عواكس هاوسهولدر:

\[Q = \prod_{i=1}^{\min(m,n)} (I - \tau_i v_i v_i^T).\]

تنتج عملية التكرار في التحليل المكونات Q، R، وp.

يمتلك الكائن ثلاثة حقول:

• factors هي مصفوفة بحجم m×n.

  • تحتوي الجزء العلوي المثلثي على عناصر $R$، أي أن R = triu(F.factors) لكائن QR هو F.
  • تحتوي الجزء تحت القطر على العواكس $v_i$ المخزنة في تنسيق مضغوط حيث $v_i$ هو العمود $i$ من المصفوفة V = I + tril(F.factors, -1).

• τ هو متجه بطول min(m,n) يحتوي على المعاملات $au_i$.

• jpvt هو متجه صحيح بطول n يتوافق مع التبديل $P$.

qr(A::SparseMatrixCSC; tol=_default_tol(A), ordering=ORDERING_DEFAULT) -> QRSparse

احسب تحليل QR لمصفوفة متفرقة A. يتم استخدام تبديلات الصفوف والأعمدة التي تقلل من التعبئة بحيث F.R = F.Q'*A[F.prow,F.pcol]. التطبيق الرئيسي لهذا النوع هو حل مشاكل المربعات الصغرى أو المشاكل غير المحددة باستخدام \. تستدعي الدالة مكتبة C SPQR^[ACM933].

!!! ملاحظة qr(A::SparseMatrixCSC) يستخدم مكتبة SPQR التي هي جزء من SuiteSparse. حيث أن هذه المكتبة تدعم فقط المصفوفات المتفرقة التي تحتوي على عناصر من نوع Float64 أو ComplexF64، اعتبارًا من Julia v1.4، يقوم qr بتحويل A إلى نسخة من النوع SparseMatrixCSC{Float64} أو SparseMatrixCSC{ComplexF64} حسب الاقتضاء.

أمثلة

julia> A = sparse([1,2,3,4], [1,1,2,2], [1.0,1.0,1.0,1.0])
4×2 SparseMatrixCSC{Float64, Int64} with 4 stored entries:
 1.0   ⋅
 1.0   ⋅
  ⋅   1.0
  ⋅   1.0

julia> qr(A)
SparseArrays.SPQR.QRSparse{Float64, Int64}
Q factor:
4×4 SparseArrays.SPQR.QRSparseQ{Float64, Int64}
R factor:
2×2 SparseMatrixCSC{Float64, Int64} with 2 stored entries:
 -1.41421    ⋅
   ⋅       -1.41421
Row permutation:
4-element Vector{Int64}:
 1
 3
 4
 2
Column permutation:
2-element Vector{Int64}:
 1
 2

qr(A, pivot = NoPivot(); blocksize) -> F

احسب تحليل QR للمصفوفة A: مصفوفة متعامدة (أو موحدة إذا كانت A ذات قيم مركبة) Q، ومصفوفة مثلثية علوية R بحيث

\[A = Q R\]

يخزن الكائن المعاد F التحليل في تنسيق مضغوط:

• إذا كان pivot == ColumnNorm() فإن F هو كائن QRPivoted،
• خلاف ذلك إذا كان نوع العنصر في A هو نوع BLAS (Float32، Float64، ComplexF32 أو ComplexF64)، فإن F هو كائن QRCompactWY،
• خلاف ذلك F هو كائن QR.

يمكن استرداد المكونات الفردية للتحليل F عبر ملحقات الخصائص:

• F.Q: المصفوفة المتعامدة/الموحدة Q
• F.R: المصفوفة المثلثية العلوية R
• F.p: متجه التبديل للتمرير (QRPivoted فقط)
• F.P: مصفوفة التبديل للتمرير (QRPivoted فقط)

!!! ملاحظة كل إشارة إلى العامل المثلثي العلوي عبر F.R يخصص مصفوفة جديدة. لذلك من المستحسن تخزين تلك المصفوفة، على سبيل المثال، بواسطة R = F.R ومتابعة العمل مع R.

تنتج عملية التكرار على التحليل المكونات Q، R، وإذا كانت موجودة p.

تتوفر الوظائف التالية لكائنات QR: inv، size، و\. عندما تكون A مستطيلة، ستعيد \ حلاً لأقل المربعات وإذا لم يكن الحل فريداً، يتم إرجاع الحل بأقل معيار. عندما لا تكون A كاملة الرتبة، يتطلب التحليل مع (العمود) التبديل للحصول على حل بأقل معيار.

يسمح بالضرب بالنسبة لـ Q كاملة/مربعة أو غير كاملة/مربعة، أي أن كلا من F.Q*F.R و F.Q*A مدعومة. يمكن تحويل مصفوفة Q إلى مصفوفة عادية باستخدام Matrix. تعيد هذه العملية عامل Q "الرقيق"، أي، إذا كانت A هي m×n مع m>=n، فإن Matrix(F.Q) ينتج مصفوفة m×n بأعمدة متعامدة. لاسترداد عامل Q "الكامل"، وهو مصفوفة متعامدة m×m، استخدم F.Q*I أو collect(F.Q). إذا كانت m<=n، فإن Matrix(F.Q) ينتج مصفوفة متعامدة m×m.

يمكن تحديد حجم الكتلة لتحليل QR بواسطة وسيط الكلمة blocksize :: Integer عندما يكون pivot == NoPivot() و A isa StridedMatrix{<:BlasFloat}. يتم تجاهله عندما يكون blocksize > minimum(size(A)). انظر QRCompactWY.

!!! توافق "جوليا 1.4" يتطلب وسيط الكلمة blocksize جوليا 1.4 أو أحدث.

أمثلة

julia> A = [3.0 -6.0; 4.0 -8.0; 0.0 1.0]
3×2 Matrix{Float64}:
 3.0  -6.0
 4.0  -8.0
 0.0   1.0

julia> F = qr(A)
LinearAlgebra.QRCompactWY{Float64, Matrix{Float64}, Matrix{Float64}}
Q factor: 3×3 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}, Matrix{Float64}}
R factor:
2×2 Matrix{Float64}:
 -5.0  10.0
  0.0  -1.0

julia> F.Q * F.R == A
true

!!! ملاحظة qr تعيد أنواع متعددة لأن LAPACK تستخدم عدة تمثيلات تقلل من متطلبات تخزين الذاكرة لمنتجات عواكس هوسهولدر الأساسية، بحيث يمكن تخزين مصفوفتا Q و R بشكل مضغوط بدلاً من مصفوفتين كثيفتين منفصلتين.

qr!(A, pivot = NoPivot(); blocksize)

qr! هو نفسه كما في qr عندما يكون A من نوع فرعي لـ AbstractMatrix، ولكنه يوفر المساحة عن طريق الكتابة فوق المدخل A، بدلاً من إنشاء نسخة. يتم رمي استثناء InexactError إذا كانت التحليل ينتج عنه رقم لا يمكن تمثيله بواسطة نوع عنصر A، على سبيل المثال، بالنسبة لأنواع الأعداد الصحيحة.

أمثلة

julia> a = [1. 2.; 3. 4.]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> qr!(a)
LinearAlgebra.QRCompactWY{Float64, Matrix{Float64}, Matrix{Float64}}
Q factor: 2×2 LinearAlgebra.QRCompactWYQ{Float64, Matrix{Float64}, Matrix{Float64}}
R factor:
2×2 Matrix{Float64}:
 -3.16228  -4.42719
  0.0      -0.632456

julia> a = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> qr!(a)
ERROR: InexactError: Int64(3.1622776601683795)
Stacktrace:
[...]

LQ <: Factorization

نوع تحليل المصفوفات لـ LQ لتحليل مصفوفة A. تحليل LQ هو تحليل QR لـ transpose(A). هذا هو نوع الإرجاع لـ lq، دالة تحليل المصفوفات المقابلة.

إذا كان S::LQ هو كائن التحليل، يمكن الحصول على المكون المثلث السفلي عبر S.L، والمكون العمودي/الوحدوي عبر S.Q، بحيث A ≈ S.L*S.Q.

تنتج عملية التكرار على التحليل المكونات S.L و S.Q.

أمثلة

julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> S = lq(A)
LQ{Float64, Matrix{Float64}, Vector{Float64}}
L factor:
2×2 Matrix{Float64}:
 -8.60233   0.0
  4.41741  -0.697486
Q factor: 2×2 LinearAlgebra.LQPackedQ{Float64, Matrix{Float64}, Vector{Float64}}

julia> S.L * S.Q
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> l, q = S; # تدمير عبر التكرار

julia> l == S.L &&  q == S.Q
true

lq(A) -> S::LQ

احسب تحليل LQ لـ A. يمكن الحصول على المكون المثلثي السفلي للتحليل من كائن LQ S عبر S.L، والمكون المتعامد/الوحدوي عبر S.Q، بحيث A ≈ S.L*S.Q.

يؤدي تكرار التحليل إلى إنتاج المكونات S.L و S.Q.

تحليل LQ هو تحليل QR لـ transpose(A)، وهو مفيد من أجل حساب الحل الأدنى المعايير lq(A) \ b لنظام معادلات غير محدد (A يحتوي على أعمدة أكثر من الصفوف، ولكنه يمتلك رتبة صف كاملة).

أمثلة

julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> S = lq(A)
LQ{Float64, Matrix{Float64}, Vector{Float64}}
L factor:
2×2 Matrix{Float64}:
 -8.60233   0.0
  4.41741  -0.697486
Q factor: 2×2 LinearAlgebra.LQPackedQ{Float64, Matrix{Float64}, Vector{Float64}}

julia> S.L * S.Q
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> l, q = S; # تدمير عبر التكرار

julia> l == S.L &&  q == S.Q
true

lq!(A) -> LQ

احسب تحليل LQ لمصفوفة A، باستخدام المصفوفة المدخلة كمساحة عمل. انظر أيضًا lq.

BunchKaufman <: Factorization

نوع تحليل المصفوفة من تحليل بونش-كوفمان لمصفوفة متناظرة أو هيرميتية A كـ P'UDU'P أو P'LDL'P، اعتمادًا على ما إذا كانت المثلث العلوي (الافتراضي) أو السفلي مخزنة في A. إذا كانت A متناظرة معقدة، فإن U' و L' تشير إلى المصفوفات المنقولة غير المترافقة، أي transpose(U) و transpose(L)، على التوالي. هذا هو نوع الإرجاع لـ bunchkaufman، دالة تحليل المصفوفة المقابلة.

إذا كانت S::BunchKaufman هي كائن التحليل، يمكن الحصول على المكونات عبر S.D، S.U أو S.L حسب ما هو مناسب بالنظر إلى S.uplo و S.p.

تنتج عملية التكرار على التحليل المكونات S.D، S.U أو S.L حسب ما هو مناسب بالنظر إلى S.uplo و S.p.

أمثلة

julia> A = Float64.([1 2; 2 3])
2×2 Matrix{Float64}:
 1.0  2.0
 2.0  3.0

julia> S = bunchkaufman(A) # A gets wrapped internally by Symmetric(A)
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 -0.333333  0.0
  0.0       3.0
U factor:
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  0.666667
  ⋅   1.0
permutation:
2-element Vector{Int64}:
 1
 2

julia> d, u, p = S; # destructuring via iteration

julia> d == S.D && u == S.U && p == S.p
true

julia> S = bunchkaufman(Symmetric(A, :L))
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 3.0   0.0
 0.0  -0.333333
L factor:
2×2 UnitLowerTriangular{Float64, Matrix{Float64}}:
 1.0        ⋅
 0.666667  1.0
permutation:
2-element Vector{Int64}:
 2
 1

bunchkaufman(A, rook::Bool=false; check = true) -> S::BunchKaufman

احسب تحليل بونش-كوفمان ^[Bunch1977] لمصفوفة متناظرة أو هيرميتية A كـ P'*U*D*U'*P أو P'*L*D*L'*P، اعتمادًا على أي مثلث مخزن في A، وأعد كائن BunchKaufman. لاحظ أنه إذا كانت A متناظرة معقدة، فإن U' و L' تشير إلى المصفوفات المنقولة غير المترافقة، أي transpose(U) و transpose(L).

يؤدي تكرار التحليل إلى إنتاج المكونات S.D، S.U أو S.L حسب ما هو مناسب بالنظر إلى S.uplo، و S.p.

إذا كانت rook تساوي true، يتم استخدام التدوير الروكي. إذا كانت rook تساوي false، فلا يتم استخدام التدوير الروكي.

عندما تكون check = true، يتم إلقاء خطأ إذا فشل التحليل. عندما تكون check = false، تقع مسؤولية التحقق من صحة التحليل (عبر issuccess) على عاتق المستخدم.

تتوفر الوظائف التالية لكائنات BunchKaufman: size، \، inv، issymmetric، ishermitian، getindex.

أمثلة

julia> A = Float64.([1 2; 2 3])
2×2 Matrix{Float64}:
 1.0  2.0
 2.0  3.0

julia> S = bunchkaufman(A) # يتم لف A داخليًا بواسطة Symmetric(A)
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 -0.333333  0.0
  0.0       3.0
U factor:
2×2 UnitUpperTriangular{Float64, Matrix{Float64}}:
 1.0  0.666667
  ⋅   1.0
permutation:
2-element Vector{Int64}:
 1
 2

julia> d, u, p = S; # تفكيك عبر التكرار

julia> d == S.D && u == S.U && p == S.p
true

julia> S.U*S.D*S.U' - S.P*A*S.P'
2×2 Matrix{Float64}:
 0.0  0.0
 0.0  0.0

julia> S = bunchkaufman(Symmetric(A, :L))
BunchKaufman{Float64, Matrix{Float64}, Vector{Int64}}
D factor:
2×2 Tridiagonal{Float64, Vector{Float64}}:
 3.0   0.0
 0.0  -0.333333
L factor:
2×2 UnitLowerTriangular{Float64, Matrix{Float64}}:
 1.0        ⋅
 0.666667  1.0
permutation:
2-element Vector{Int64}:
 2
 1

julia> S.L*S.D*S.L' - A[S.p, S.p]
2×2 Matrix{Float64}:
 0.0  0.0
 0.0  0.0

bunchkaufman!(A, rook::Bool=false; check = true) -> BunchKaufman

bunchkaufman! هو نفس bunchkaufman، ولكنه يوفر المساحة عن طريق الكتابة فوق المدخل A، بدلاً من إنشاء نسخة.

Eigen <: Factorization

نوع تحليل المصفوفة لتفكيك القيم الذاتية/الطيفية لمصفوفة مربعة A. هذا هو نوع الإرجاع لـ eigen، دالة تحليل المصفوفة المقابلة.

إذا كان F::Eigen هو كائن التحليل، يمكن الحصول على القيم الذاتية عبر F.values والمتجهات الذاتية كأعمدة من المصفوفة F.vectors. (يمكن الحصول على المتجه الذاتي k من الشريحة F.vectors[:, k].)

يؤدي تكرار التفكيك إلى إنتاج المكونات F.values و F.vectors.

أمثلة

julia> F = eigen([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
Eigen{Float64, Float64, Matrix{Float64}, Vector{Float64}}
values:
3-element Vector{Float64}:
  1.0
  3.0
 18.0
vectors:
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> F.values
3-element Vector{Float64}:
  1.0
  3.0
 18.0

julia> F.vectors
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> vals, vecs = F; # destructuring via iteration

julia> vals == F.values && vecs == F.vectors
true

GeneralizedEigen <: Factorization

نوع تحليل المصفوفات لتفكيك القيم الذاتية/الطيفية العامة لـ A و B. هذا هو نوع الإرجاع لـ eigen، وظيفة تحليل المصفوفات المقابلة، عند استدعائها مع وسيطين مصفوفيين.

إذا كان F::GeneralizedEigen هو كائن التحليل، يمكن الحصول على القيم الذاتية عبر F.values والمتجهات الذاتية كأعمدة المصفوفة F.vectors. (يمكن الحصول على المتجه الذاتي k من الشريحة F.vectors[:, k].)

يؤدي تكرار التفكيك إلى إنتاج المكونات F.values و F.vectors.

أمثلة

julia> A = [1 0; 0 -1]
2×2 Matrix{Int64}:
 1   0
 0  -1

julia> B = [0 1; 1 0]
2×2 Matrix{Int64}:
 0  1
 1  0

julia> F = eigen(A, B)
GeneralizedEigen{ComplexF64, ComplexF64, Matrix{ComplexF64}, Vector{ComplexF64}}
values:
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im
vectors:
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

julia> F.values
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im

julia> F.vectors
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

julia> vals, vecs = F; # destructuring via iteration

julia> vals == F.values && vecs == F.vectors
true

eigvals(A; permute::Bool=true, scale::Bool=true, sortby) -> values

إرجاع القيم الذاتية لـ A.

بالنسبة للمصفوفات غير المتماثلة العامة، من الممكن تحديد كيفية توازن المصفوفة قبل حساب القيم الذاتية. الكلمات الرئيسية permute و scale و sortby هي نفسها المستخدمة في eigen.

أمثلة

julia> diag_matrix = [1 0; 0 4]
2×2 Matrix{Int64}:
 1  0
 0  4

julia> eigvals(diag_matrix)
2-element Vector{Float64}:
 1.0
 4.0

لإدخال عددي، ستعيد eigvals عددًا عدديًا.

أمثلة

julia> eigvals(-2)
-2

eigvals(A, B) -> values

احسب القيم الذاتية العامة لـ A و B.

أمثلة

julia> A = [1 0; 0 -1]
2×2 Matrix{Int64}:
 1   0
 0  -1

julia> B = [0 1; 1 0]
2×2 Matrix{Int64}:
 0  1
 1  0

julia> eigvals(A,B)
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im

eigvals(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> values

إرجاع القيم الذاتية لـ A. من الممكن حساب مجموعة فرعية فقط من القيم الذاتية عن طريق تحديد UnitRange irange التي تغطي مؤشرات القيم الذاتية المرتبة، على سبيل المثال، القيم الذاتية من الثانية إلى الثامنة.

أمثلة

julia> A = SymTridiagonal([1.; 2.; 1.], [2.; 3.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 1.0  2.0   ⋅
 2.0  2.0  3.0
  ⋅   3.0  1.0

julia> eigvals(A, 2:2)
1-element Vector{Float64}:
 0.9999999999999996

julia> eigvals(A)
3-element Vector{Float64}:
 -2.1400549446402604
  1.0000000000000002
  5.140054944640259

eigvals(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> values

إرجاع القيم الذاتية لـ A. من الممكن حساب مجموعة فرعية فقط من القيم الذاتية عن طريق تحديد زوج vl و vu للحدود السفلية والعلوية للقيم الذاتية.

أمثلة

julia> A = SymTridiagonal([1.; 2.; 1.], [2.; 3.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 1.0  2.0   ⋅
 2.0  2.0  3.0
  ⋅   3.0  1.0

julia> eigvals(A, -1, 2)
1-element Vector{Float64}:
 1.0000000000000009

julia> eigvals(A)
3-element Vector{Float64}:
 -2.1400549446402604
  1.0000000000000002
  5.140054944640259

eigvals!(A; permute::Bool=true, scale::Bool=true, sortby) -> values

نفس الشيء كما في eigvals، ولكن يوفر المساحة عن طريق الكتابة فوق المدخل A، بدلاً من إنشاء نسخة. الكلمات الرئيسية permute و scale و sortby هي نفسها كما في eigen.

!!! ملاحظة لن تحتوي مصفوفة الإدخال A على قيمها الذاتية بعد استدعاء eigvals! عليها - يتم استخدام A كمساحة عمل.

أمثلة

julia> A = [1. 2.; 3. 4.]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> eigvals!(A)
2-element Vector{Float64}:
 -0.3722813232690143
  5.372281323269014

julia> A
2×2 Matrix{Float64}:
 -0.372281  -1.0
  0.0        5.37228

eigvals!(A, B; sortby) -> values

نفس eigvals، ولكن يوفر المساحة عن طريق الكتابة فوق المدخلات A (و B)، بدلاً من إنشاء نسخ.

!!! ملاحظة المصفوفات المدخلة A و B لن تحتوي على قيمها الذاتية بعد استدعاء eigvals!. يتم استخدامها كمساحات عمل.

أمثلة

julia> A = [1. 0.; 0. -1.]
2×2 Matrix{Float64}:
 1.0   0.0
 0.0  -1.0

julia> B = [0. 1.; 1. 0.]
2×2 Matrix{Float64}:
 0.0  1.0
 1.0  0.0

julia> eigvals!(A, B)
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im

julia> A
2×2 Matrix{Float64}:
 -0.0  -1.0
  1.0  -0.0

julia> B
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0

eigvals!(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> values

نفس الشيء كما في eigvals، ولكن يوفر المساحة عن طريق الكتابة فوق المدخل A، بدلاً من إنشاء نسخة. irange هو نطاق من مؤشرات القيم الذاتية للبحث عنها - على سبيل المثال، من القيم الذاتية الثانية إلى الثامنة.

eigvals!(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> values

نفس الشيء كما في eigvals، ولكن يوفر المساحة عن طريق الكتابة فوق المدخل A، بدلاً من إنشاء نسخة. vl هو الحد الأدنى للفترة للبحث عن القيم الذاتية، و vu هو الحد الأقصى.

eigmax(A; permute::Bool=true, scale::Bool=true)

إرجاع أكبر قيمة ذاتية لـ A. الخيار permute=true يقوم بترتيب المصفوفة لتصبح أقرب إلى مثلث علوي، و scale=true يقوم بتعديل المصفوفة بواسطة عناصرها القطرية لجعل الصفوف والأعمدة أكثر تساويًا في المعيار. لاحظ أنه إذا كانت القيم الذاتية لـ A معقدة، فإن هذه الطريقة ستفشل، حيث لا يمكن فرز الأعداد المعقدة.

أمثلة

julia> A = [0 im; -im 0]
2×2 Matrix{Complex{Int64}}:
 0+0im  0+1im
 0-1im  0+0im

julia> eigmax(A)
1.0

julia> A = [0 im; -1 0]
2×2 Matrix{Complex{Int64}}:
  0+0im  0+1im
 -1+0im  0+0im

julia> eigmax(A)
ERROR: DomainError with Complex{Int64}[0+0im 0+1im; -1+0im 0+0im]:
`A` cannot have complex eigenvalues.
Stacktrace:
[...]

eigmin(A; permute::Bool=true, scale::Bool=true)

إرجاع أصغر قيمة ذاتية لـ A. الخيار permute=true يقوم بترتيب المصفوفة لتصبح أقرب إلى مثلث علوي، و scale=true يقوم بتعديل المصفوفة بواسطة عناصرها القطرية لجعل الصفوف والأعمدة أكثر تساويًا في المعيار. لاحظ أنه إذا كانت القيم الذاتية لـ A معقدة، فإن هذه الطريقة ستفشل، حيث لا يمكن فرز الأعداد المعقدة.

أمثلة

julia> A = [0 im; -im 0]
2×2 Matrix{Complex{Int64}}:
 0+0im  0+1im
 0-1im  0+0im

julia> eigmin(A)
-1.0

julia> A = [0 im; -1 0]
2×2 Matrix{Complex{Int64}}:
  0+0im  0+1im
 -1+0im  0+0im

julia> eigmin(A)
ERROR: DomainError with Complex{Int64}[0+0im 0+1im; -1+0im 0+0im]:
`A` cannot have complex eigenvalues.
Stacktrace:
[...]

eigvecs(A::SymTridiagonal[, eigvals]) -> Matrix

إرجاع مصفوفة M تكون أعمدتها هي المتجهات الذاتية لـ A. (يمكن الحصول على المتجه الذاتي k من الشريحة M[:, k].)

إذا تم تحديد المتجه الاختياري للقيم الذاتية eigvals، فإن eigvecs ترجع المتجهات الذاتية المقابلة المحددة.

أمثلة

julia> A = SymTridiagonal([1.; 2.; 1.], [2.; 3.])
3×3 SymTridiagonal{Float64, Vector{Float64}}:
 1.0  2.0   ⋅
 2.0  2.0  3.0
  ⋅   3.0  1.0

julia> eigvals(A)
3-element Vector{Float64}:
 -2.1400549446402604
  1.0000000000000002
  5.140054944640259

julia> eigvecs(A)
3×3 Matrix{Float64}:
  0.418304  -0.83205      0.364299
 -0.656749  -7.39009e-16  0.754109
  0.627457   0.5547       0.546448

julia> eigvecs(A, [1.])
3×1 Matrix{Float64}:
  0.8320502943378438
  4.263514128092366e-17
 -0.5547001962252291

eigvecs(A; permute::Bool=true, scale::Bool=true, `sortby`) -> Matrix

إرجاع مصفوفة M تكون أعمدتها هي المتجهات الذاتية لـ A. (يمكن الحصول على المتجه الذاتي k من الشريحة M[:, k].) الكلمات الرئيسية permute و scale و sortby هي نفسها كما في eigen.

أمثلة

julia> eigvecs([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

eigvecs(A, B) -> Matrix

إرجاع مصفوفة M تكون أعمدتها هي القيم الذاتية العامة لـ A و B. (يمكن الحصول على القيمة الذاتية k من الشريحة M[:, k].)

أمثلة

julia> A = [1 0; 0 -1]
2×2 Matrix{Int64}:
 1   0
 0  -1

julia> B = [0 1; 1 0]
2×2 Matrix{Int64}:
 0  1
 1  0

julia> eigvecs(A, B)
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

eigen(A; permute::Bool=true, scale::Bool=true, sortby) -> Eigen

احسب تحليل القيم الذاتية لـ A، معيدًا كائن تحليل Eigen F الذي يحتوي على القيم الذاتية في F.values والمتجهات الذاتية في أعمدة المصفوفة F.vectors. هذا يتوافق مع حل مشكلة القيم الذاتية بالشكل Ax = λx، حيث A هي مصفوفة، وx هو متجه ذاتي، وλ هو قيمة ذاتية. (يمكن الحصول على المتجه الذاتي k من الشريحة F.vectors[:, k].)

تنتج عملية تكرار التحليل المكونات F.values و F.vectors.

تتوفر الوظائف التالية لكائنات Eigen: inv، det، و isposdef.

بالنسبة للمصفوفات غير المتماثلة العامة، من الممكن تحديد كيفية توازن المصفوفة قبل حساب المتجه الذاتي. الخيار permute=true يقوم بإعادة ترتيب المصفوفة لتصبح أقرب إلى مثلث علوي، و scale=true يقوم بتعديل المصفوفة بواسطة عناصرها القطرية لجعل الصفوف والأعمدة أكثر تساويًا في المعيار. القيمة الافتراضية هي true لكلا الخيارين.

بشكل افتراضي، يتم فرز القيم الذاتية والمتجهات بشكل قوامي حسب (real(λ),imag(λ)). يمكن تمرير دالة مقارنة مختلفة by(λ) إلى sortby، أو يمكنك تمرير sortby=nothing لترك القيم الذاتية في ترتيب عشوائي. بعض أنواع المصفوفات الخاصة (مثل Diagonal أو SymTridiagonal) قد تنفذ تقليد فرز خاص بها ولا تقبل كلمة sortby.

أمثلة

julia> F = eigen([1.0 0.0 0.0; 0.0 3.0 0.0; 0.0 0.0 18.0])
Eigen{Float64, Float64, Matrix{Float64}, Vector{Float64}}
values:
3-element Vector{Float64}:
  1.0
  3.0
 18.0
vectors:
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> F.values
3-element Vector{Float64}:
  1.0
  3.0
 18.0

julia> F.vectors
3×3 Matrix{Float64}:
 1.0  0.0  0.0
 0.0  1.0  0.0
 0.0  0.0  1.0

julia> vals, vecs = F; # تدمير عبر التكرار

julia> vals == F.values && vecs == F.vectors
true

eigen(A, B; sortby) -> GeneralizedEigen

احسب تحليل القيم الذاتية العامة لـ A و B، مع إرجاع كائن تحليل GeneralizedEigen F الذي يحتوي على القيم الذاتية العامة في F.values والمتجهات الذاتية العامة في أعمدة المصفوفة F.vectors. هذا يتوافق مع حل مشكلة القيم الذاتية العامة بالشكل Ax = λBx، حيث A, B هما مصفوفتان، و x هو متجه ذاتي، و λ هو قيمة ذاتية. (يمكن الحصول على المتجه الذاتي العام k من الشريحة F.vectors[:, k].)

يؤدي تكرار التحليل إلى إنتاج المكونات F.values و F.vectors.

بشكل افتراضي، يتم فرز القيم الذاتية والمتجهات بترتيب معجمي حسب (real(λ),imag(λ)). يمكن تمرير دالة مقارنة مختلفة by(λ) إلى sortby، أو يمكنك تمرير sortby=nothing لترك القيم الذاتية في ترتيب عشوائي.

أمثلة

julia> A = [1 0; 0 -1]
2×2 Matrix{Int64}:
 1   0
 0  -1

julia> B = [0 1; 1 0]
2×2 Matrix{Int64}:
 0  1
 1  0

julia> F = eigen(A, B);

julia> F.values
2-element Vector{ComplexF64}:
 0.0 - 1.0im
 0.0 + 1.0im

julia> F.vectors
2×2 Matrix{ComplexF64}:
  0.0+1.0im   0.0-1.0im
 -1.0+0.0im  -1.0-0.0im

julia> vals, vecs = F; # destructuring via iteration

julia> vals == F.values && vecs == F.vectors
true

eigen(A::Union{SymTridiagonal, Hermitian, Symmetric}, irange::UnitRange) -> Eigen

احسب تحليل القيم الذاتية لـ A، معيدًا كائن تحليل Eigen F الذي يحتوي على القيم الذاتية في F.values والمتجهات الذاتية في أعمدة المصفوفة F.vectors. (يمكن الحصول على المتجه الذاتي k من الشريحة F.vectors[:, k].)

يؤدي تكرار التحليل إلى إنتاج المكونات F.values و F.vectors.

تتوفر الوظائف التالية لكائنات Eigen: inv، det، و isposdef.

تحدد UnitRange irange مؤشرات القيم الذاتية المرتبة للبحث عنها.

!!! ملاحظة إذا لم يكن irange هو 1:n، حيث n هو بعد A، فإن التحليل المعاد سيكون تحليلًا مقتطعًا.

eigen(A::Union{SymTridiagonal, Hermitian, Symmetric}, vl::Real, vu::Real) -> Eigen

احسب تحليل القيم الذاتية لـ A، معيدًا كائن تحليل Eigen F الذي يحتوي على القيم الذاتية في F.values والمتجهات الذاتية في أعمدة المصفوفة F.vectors. (يمكن الحصول على المتجه الذاتي k من الشريحة F.vectors[:, k].)

يؤدي تكرار التحليل إلى إنتاج المكونات F.values و F.vectors.

تتوفر الوظائف التالية لكائنات Eigen: inv، det، و isposdef.

vl هو الحد الأدنى من نافذة القيم الذاتية للبحث عنها، و vu هو الحد الأقصى.

!!! ملاحظة إذا كانت [vl, vu] لا تحتوي على جميع القيم الذاتية لـ A، فإن التحليل المعاد سيكون تحليلًا مقتطعًا.

eigen!(A; permute, scale, sortby)
eigen!(A, B; sortby)

نفس eigen، ولكن يوفر المساحة عن طريق الكتابة فوق المدخل A (و B)، بدلاً من إنشاء نسخة.

Hessenberg <: Factorization

يمثل كائن Hessenberg تحليل هيسنبرغ QHQ' لمصفوفة مربعة، أو إزاحة Q(H+μI)Q' منها، والتي يتم إنتاجها بواسطة دالة hessenberg.

hessenberg(A) -> Hessenberg

احسب تحليل هيسنبرغ لـ A وأعد كائن Hessenberg. إذا كان F هو كائن التحليل، يمكن الوصول إلى المصفوفة الوحدوية باستخدام F.Q (من نوع LinearAlgebra.HessenbergQ) ومصفوفة هيسنبرغ باستخدام F.H (من نوع UpperHessenberg)، أي منهما يمكن تحويله إلى مصفوفة عادية باستخدام Matrix(F.H) أو Matrix(F.Q).

إذا كانت A هي Hermitian أو Symmetric حقيقية، فإن تحليل هيسنبرغ ينتج مصفوفة ثلاثية القيم حقيقية ومتناظرة وF.H من نوع SymTridiagonal.

لاحظ أن التحليل المنزلق A+μI = Q (H+μI) Q' يمكن بناؤه بكفاءة بواسطة F + μ*I باستخدام كائن UniformScaling I، الذي ينشئ كائن Hessenberg جديد مع تخزين مشترك وتحويل معدل. يتم الحصول على التحويل لـ F المعطاة بواسطة F.μ. هذا مفيد لأن الحلول المنزلق المتعددة (F + μ*I) \ b (لـ μ و/أو b مختلفة) يمكن تنفيذها بكفاءة بمجرد إنشاء F.

تنتج عملية تكرار التحليل العوامل F.Q, F.H, F.μ.

أمثلة

julia> A = [4. 9. 7.; 4. 4. 1.; 4. 3. 2.]
3×3 Matrix{Float64}:
 4.0  9.0  7.0
 4.0  4.0  1.0
 4.0  3.0  2.0

julia> F = hessenberg(A)
Hessenberg{Float64, UpperHessenberg{Float64, Matrix{Float64}}, Matrix{Float64}, Vector{Float64}, Bool}
Q factor: 3×3 LinearAlgebra.HessenbergQ{Float64, Matrix{Float64}, Vector{Float64}, false}
H factor:
3×3 UpperHessenberg{Float64, Matrix{Float64}}:
  4.0      -11.3137       -1.41421
 -5.65685    5.0           2.0
   ⋅        -8.88178e-16   1.0

julia> F.Q * F.H * F.Q'
3×3 Matrix{Float64}:
 4.0  9.0  7.0
 4.0  4.0  1.0
 4.0  3.0  2.0

julia> q, h = F; # تدمير عبر التكرار

julia> q == F.Q && h == F.H
true

hessenberg!(A) -> Hessenberg

hessenberg! هو نفس hessenberg، ولكنه يوفر المساحة عن طريق الكتابة فوق المدخل A، بدلاً من إنشاء نسخة.

Schur <: Factorization

نوع تحليل المصفوفة من تحليل شُور لمصفوفة A. هذا هو نوع الإرجاع لـ schur(_)، دالة تحليل المصفوفة المقابلة.

إذا كان F::Schur هو كائن التحليل، يمكن الحصول على عامل شُور (شبه) المثلث عبر إما F.Schur أو F.T و المتجهات الشُورية/الوحدوية عبر F.vectors أو F.Z بحيث A = F.vectors * F.Schur * F.vectors'. يمكن الحصول على القيم الذاتية لـ A باستخدام F.values.

يؤدي تكرار التحليل إلى إنتاج المكونات F.T، F.Z، و F.values.

أمثلة

julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> F = schur(A)
Schur{Float64, Matrix{Float64}, Vector{Float64}}
T factor:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z factor:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
eigenvalues:
2-element Vector{Float64}:
  3.0
 -2.0

julia> F.vectors * F.Schur * F.vectors'
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> t, z, vals = F; # destructuring via iteration

julia> t == F.T && z == F.Z && vals == F.values
true

GeneralizedSchur <: Factorization

نوع تحليل المصفوفات لتحليل شُور العام لمصفوفتين A و B. هذا هو نوع الإرجاع لـ schur(_, _)، دالة تحليل المصفوفات المقابلة.

إذا كان F::GeneralizedSchur هو كائن التحليل، يمكن الحصول على عوامل شُور (شبه) مثلثية عبر F.S و F.T، وعبر F.left أو F.Q يمكن الحصول على المتجهات الشُورية اليسرى الموحدة/الأرثوجونالية، ويمكن الحصول على المتجهات الشُورية اليمنى الموحدة/الأرثوجونالية باستخدام F.right أو F.Z بحيث A=F.left*F.S*F.right' و B=F.left*F.T*F.right'. يمكن الحصول على القيم الذاتية العامة لـ A و B باستخدام F.α./F.β.

تنتج عملية تكرار التحليل المكونات F.S، F.T، F.Q، F.Z، F.α، و F.β.

schur(A) -> F::Schur

يحسب تحليل شير لمصفوفة A. يمكن الحصول على عامل شير (شبه) مثلث من كائن Schur F إما باستخدام F.Schur أو F.T ويمكن الحصول على المتجهات الشير orthogonal/unitary باستخدام F.vectors أو F.Z بحيث A = F.vectors * F.Schur * F.vectors'. يمكن الحصول على القيم الذاتية لـ A باستخدام F.values.

بالنسبة لـ A الحقيقية، فإن تحليل شير هو "شبه مثلث"، مما يعني أنه مثلث علوي باستثناء وجود كتل قطرية 2×2 لأي زوج مترافق من القيم الذاتية المعقدة؛ وهذا يسمح بأن يكون التحليل حقيقيًا بحتًا حتى عندما تكون هناك قيم ذاتية معقدة. للحصول على تحليل شير (معقد) مثلث علوي بحت من تحليل شبه مثلث حقيقي، يمكنك استخدام Schur{Complex}(schur(A)).

تنتج عملية التكرار في التحليل المكونات F.T و F.Z و F.values.

أمثلة

julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> F = schur(A)
Schur{Float64, Matrix{Float64}, Vector{Float64}}
T factor:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z factor:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
eigenvalues:
2-element Vector{Float64}:
  3.0
 -2.0

julia> F.vectors * F.Schur * F.vectors'
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> t, z, vals = F; # destructuring via iteration

julia> t == F.T && z == F.Z && vals == F.values
true

schur(A, B) -> F::GeneralizedSchur

يحسب التحليل العام للـ Schur (أو QZ) للمصفوفتين A و B. يمكن الحصول على عوامل Schur (شبه) مثلثية من كائن Schur F باستخدام F.S و F.T، ويمكن الحصول على المتجهات Schur اليسارية الموحدة/العمودية باستخدام F.left أو F.Q، ويمكن الحصول على المتجهات Schur اليمنى الموحدة/العمودية باستخدام F.right أو F.Z بحيث A=F.left*F.S*F.right' و B=F.left*F.T*F.right'. يمكن الحصول على القيم الذاتية العامة لـ A و B باستخدام F.α./F.β.

يؤدي تكرار التحليل إلى إنتاج المكونات F.S، F.T، F.Q، F.Z، F.α، و F.β.

schur!(A) -> F::Schur

نفس الشيء كما في schur ولكن يستخدم وسيط الإدخال A كمساحة عمل.

أمثلة

julia> A = [5. 7.; -2. -4.]
2×2 Matrix{Float64}:
  5.0   7.0
 -2.0  -4.0

julia> F = schur!(A)
Schur{Float64, Matrix{Float64}, Vector{Float64}}
T factor:
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0
Z factor:
2×2 Matrix{Float64}:
  0.961524  0.274721
 -0.274721  0.961524
eigenvalues:
2-element Vector{Float64}:
  3.0
 -2.0

julia> A
2×2 Matrix{Float64}:
 3.0   9.0
 0.0  -2.0

schur!(A::StridedMatrix, B::StridedMatrix) -> F::GeneralizedSchur

نفس الشيء كما في schur ولكن يستخدم المصفوفتين المدخلتين A و B كمساحة عمل.

ordschur(F::Schur, select::Union{Vector{Bool},BitVector}) -> F::Schur

يعيد ترتيب تحليل شُور F لمصفوفة A = Z*T*Z' وفقًا للمصفوفة المنطقية select، مما يعيد كائن التحليل المعاد ترتيبه F. تظهر القيم الذاتية المختارة في القطر الرئيسي لـ F.Schur وتشكّل الأعمدة الرائدة المقابلة لـ F.vectors قاعدة متعامدة/وحيدة للفضاء الفرعي الثابت المقابل. في الحالة الحقيقية، يجب أن يتم تضمين زوج معقد مترافق من القيم الذاتية أو استبعادهما معًا عبر select.

ordschur(F::GeneralizedSchur, select::Union{Vector{Bool},BitVector}) -> F::GeneralizedSchur

يعيد ترتيب تحليل شير العام F لزوج المصفوفات (A, B) = (Q*S*Z', Q*T*Z') وفقًا للمصفوفة المنطقية select ويعيد كائن GeneralizedSchur F. تظهر القيم الذاتية المختارة في القطر الرئيسي لكل من F.S و F.T، كما يتم إعادة ترتيب المتجهات الشير اليسرى واليمنى بحيث لا يزال (A, B) = F.Q*(F.S, F.T)*F.Z' صحيحًا ويمكن الحصول على القيم الذاتية العامة لـ A و B باستخدام F.α./F.β.

ordschur!(F::Schur, select::Union{Vector{Bool},BitVector}) -> F::Schur

نفس الأمر كما في ordschur ولكن يكتب فوق التحليل F.

ordschur!(F::GeneralizedSchur, select::Union{Vector{Bool},BitVector}) -> F::GeneralizedSchur

نفس الشيء مثل ordschur ولكن يقوم بكتابة عامل التحليل F مرة أخرى.

SVD <: Factorization

نوع تحليل المصفوفة من تحليل القيمة المفردة (SVD) لمصفوفة A. هذا هو نوع الإرجاع لـ svd(_)، دالة تحليل المصفوفة المقابلة.

إذا كان F::SVD هو كائن التحليل، يمكن الحصول على U و S و V و Vt عبر F.U و F.S و F.V و F.Vt، بحيث A = U * Diagonal(S) * Vt. القيم المفردة في S مرتبة بترتيب تنازلي.

إنتاج التحليل ينتج المكونات U و S و V.

أمثلة

julia> A = [1. 0. 0. 0. 2.; 0. 0. 3. 0. 0.; 0. 0. 0. 0. 0.; 0. 2. 0. 0. 0.]
4×5 Matrix{Float64}:
 1.0  0.0  0.0  0.0  2.0
 0.0  0.0  3.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0
 0.0  2.0  0.0  0.0  0.0

julia> F = svd(A)
SVD{Float64, Float64, Matrix{Float64}, Vector{Float64}}
U factor:
4×4 Matrix{Float64}:
 0.0  1.0   0.0  0.0
 1.0  0.0   0.0  0.0
 0.0  0.0   0.0  1.0
 0.0  0.0  -1.0  0.0
singular values:
4-element Vector{Float64}:
 3.0
 2.23606797749979
 2.0
 0.0
Vt factor:
4×5 Matrix{Float64}:
 -0.0        0.0  1.0  -0.0  0.0
  0.447214   0.0  0.0   0.0  0.894427
  0.0       -1.0  0.0   0.0  0.0
  0.0        0.0  0.0   1.0  0.0

julia> F.U * Diagonal(F.S) * F.Vt
4×5 Matrix{Float64}:
 1.0  0.0  0.0  0.0  2.0
 0.0  0.0  3.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0
 0.0  2.0  0.0  0.0  0.0

julia> u, s, v = F; # destructuring via iteration

julia> u == F.U && s == F.S && v == F.V
true

GeneralizedSVD <: Factorization

نوع تحليل المصفوفات من تحليل القيمة المفردة العام (SVD) لمصفوفتين A و B، بحيث A = F.U*F.D1*F.R0*F.Q' و B = F.V*F.D2*F.R0*F.Q'. هذا هو نوع الإرجاع لـ svd(_, _)، دالة تحليل المصفوفات المقابلة.

بالنسبة لمصفوفة A بحجم M-by-N ومصفوفة B بحجم P-by-N،

• U هي مصفوفة متعامدة بحجم M-by-M،
• V هي مصفوفة متعامدة بحجم P-by-P،
• Q هي مصفوفة متعامدة بحجم N-by-N،
• D1 هي مصفوفة قطرية بحجم M-by-(K+L) تحتوي على 1s في أول K مدخلات،
• D2 هي مصفوفة بحجم P-by-(K+L) يكون فيها الكتلة العلوية اليمنى بحجم L-by-L قطرية،
• R0 هي مصفوفة بحجم (K+L)-by-N تكون فيها الكتلة اليمنى (K+L)-by-(K+L) غير مفردة ومثلثية علوية،

K+L هو الرتبة العددية الفعالة للمصفوفة [A; B].

تنتج عملية تكرار التحليل المكونات U و V و Q و D1 و D2 و R0.

تكون المدخلات في F.D1 و F.D2 مرتبطة، كما هو موضح في وثائق LAPACK لـ SVD العام وروتين xGGSVD3 الذي يتم استدعاؤه في الخلفية (في LAPACK 3.6.0 وما بعده).

أمثلة

julia> A = [1. 0.; 0. -1.]
2×2 Matrix{Float64}:
 1.0   0.0
 0.0  -1.0

julia> B = [0. 1.; 1. 0.]
2×2 Matrix{Float64}:
 0.0  1.0
 1.0  0.0

julia> F = svd(A, B)
GeneralizedSVD{Float64, Matrix{Float64}, Float64, Vector{Float64}}
U factor:
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0
V factor:
2×2 Matrix{Float64}:
 -0.0  -1.0
  1.0   0.0
Q factor:
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0
D1 factor:
2×2 Matrix{Float64}:
 0.707107  0.0
 0.0       0.707107
D2 factor:
2×2 Matrix{Float64}:
 0.707107  0.0
 0.0       0.707107
R0 factor:
2×2 Matrix{Float64}:
 1.41421   0.0
 0.0      -1.41421

julia> F.U*F.D1*F.R0*F.Q'
2×2 Matrix{Float64}:
 1.0   0.0
 0.0  -1.0

julia> F.V*F.D2*F.R0*F.Q'
2×2 Matrix{Float64}:
 -0.0  1.0
  1.0  0.0

svd(A; full::Bool = false, alg::Algorithm = default_svd_alg(A)) -> SVD

احسب تحليل القيمة المفردة (SVD) لـ A وأعد كائن SVD.

يمكن الحصول على U و S و V و Vt من التحليل F باستخدام F.U و F.S و F.V و F.Vt، بحيث A = U * Diagonal(S) * Vt. تنتج الخوارزمية Vt وبالتالي فإن استخراج Vt أكثر كفاءة من استخراج V. القيم المفردة في S مرتبة بترتيب تنازلي.

يؤدي تكرار التحليل إلى إنتاج المكونات U و S و V.

إذا كان full = false (افتراضي)، يتم إرجاع SVD "رفيع". بالنسبة لمصفوفة A بحجم $M \times N$، في التحليل الكامل يكون U بحجم $M \times M$ و V بحجم $N \times N$، بينما في التحليل الرفيع يكون U بحجم $M \times K$ و V بحجم $N \times K$، حيث $K = \min(M,N)$ هو عدد القيم المفردة.

إذا كان alg = DivideAndConquer()، يتم استخدام خوارزمية القسمة والتغلب لحساب SVD. خيار آخر (عادةً أبطأ ولكن أكثر دقة) هو alg = QRIteration().

أمثلة

julia> A = rand(4,3);

julia> F = svd(A); # تخزين كائن التحليل

julia> A ≈ F.U * Diagonal(F.S) * F.Vt
true

julia> U, S, V = F; # التفكيك عبر التكرار

julia> A ≈ U * Diagonal(S) * V'
true

julia> Uonly, = svd(A); # تخزين U فقط

julia> Uonly == U
true

svd(A, B) -> GeneralizedSVD

احسب SVD المعمم لـ A و B، معيدًا كائن تحليل GeneralizedSVD F بحيث [A;B] = [F.U * F.D1; F.V * F.D2] * F.R0 * F.Q'

• U هو مصفوفة متعامدة بحجم M-by-M،
• V هو مصفوفة متعامدة بحجم P-by-P،
• Q هو مصفوفة متعامدة بحجم N-by-N،
• D1 هو مصفوفة قطرية بحجم M-by-(K+L) تحتوي على 1s في أول K مدخلات،
• D2 هو مصفوفة بحجم P-by-(K+L) حيث الكتلة العلوية اليمنى بحجم L-by-L هي قطرية،
• R0 هو مصفوفة بحجم (K+L)-by-N حيث الكتلة اليمنى (K+L)-by-(K+L) غير مفردة ومثلثية علوية،

K+L هو الرتبة العددية الفعالة للمصفوفة [A; B].

تنتج عملية التحلل المكونات U، V، Q، D1، D2، و R0.

يستخدم SVD المعمم في التطبيقات مثل عندما يرغب المرء في مقارنة مقدار ما ينتمي إلى A مقابل مقدار ما ينتمي إلى B، كما في الجينوم البشري مقابل الخميرة، أو الإشارة مقابل الضوضاء، أو بين الكتل مقابل داخل الكتل. (انظر إيدلمان ووانغ للنقاش: https://arxiv.org/abs/1901.00485)

يقوم بتحليل [A; B] إلى [UC; VS]H، حيث [UC; VS] هو أساس متعامد طبيعي لفضاء الأعمدة لـ [A; B]، و H = RQ' هو أساس غير متعامد طبيعي لفضاء الصفوف لـ [A;B]، حيث يتم نسب الصفوف العلوية بشكل أكبر إلى مصفوفة A، والصفوف السفلية إلى مصفوفة B. توفر مصفوفات الموجات المتعددة C و S مقياسًا متعددًا لمقدار A مقابل مقدار B، وتوفر U و V اتجاهات يتم قياسها بها.

أمثلة

julia> A = randn(3,2); B=randn(4,2);

julia> F = svd(A, B);

julia> U,V,Q,C,S,R = F;

julia> H = R*Q';

julia> [A; B] ≈ [U*C; V*S]*H
true

julia> [A; B] ≈ [F.U*F.D1; F.V*F.D2]*F.R0*F.Q'
true

julia> Uonly, = svd(A,B);

julia> U == Uonly
true

svd!(A; full::Bool = false, alg::Algorithm = default_svd_alg(A)) -> SVD

svd! هو نفس svd، ولكنه يوفر المساحة عن طريق الكتابة فوق المدخل A، بدلاً من إنشاء نسخة. راجع وثائق svd للحصول على التفاصيل.

svd!(A, B) -> GeneralizedSVD

svd! هو نفس svd، ولكنه يعدل المعطيات A و B في المكان، بدلاً من إنشاء نسخ. راجع توثيق svd للحصول على التفاصيل.

svdvals(A)

إرجاع القيم الفردية لـ A بترتيب تنازلي.

أمثلة

julia> A = [1. 0. 0. 0. 2.; 0. 0. 3. 0. 0.; 0. 0. 0. 0. 0.; 0. 2. 0. 0. 0.]
4×5 Matrix{Float64}:
 1.0  0.0  0.0  0.0  2.0
 0.0  0.0  3.0  0.0  0.0
 0.0  0.0  0.0  0.0  0.0
 0.0  2.0  0.0  0.0  0.0

julia> svdvals(A)
4-element Vector{Float64}:
 3.0
 2.23606797749979
 2.0
 0.0

svdvals(A, B)

إرجاع القيم الفردية العامة من تحليل القيمة الفردية العامة لـ A و B. انظر أيضًا svd.

أمثلة

julia> A = [1. 0.; 0. -1.]
2×2 Matrix{Float64}:
 1.0   0.0
 0.0  -1.0

julia> B = [0. 1.; 1. 0.]
2×2 Matrix{Float64}:
 0.0  1.0
 1.0  0.0

julia> svdvals(A, B)
2-element Vector{Float64}:
 1.0
 1.0

svdvals!(A)

إرجاع القيم الفردية لـ A، مع توفير المساحة عن طريق الكتابة فوق المدخلات. انظر أيضًا svdvals و svd.

svdvals!(A, B)

إرجاع القيم الفردية العامة من تحليل القيمة الفردية العامة لـ A و B، مع توفير المساحة عن طريق الكتابة فوق A و B. انظر أيضًا svd و svdvals.

LinearAlgebra.Givens(i1,i2,c,s) -> G

مشغل خطي لتدوير غيفنز. تمثل الحقول c و s جيب التمام وجيب زاوية التدوير، على التوالي. يدعم نوع Givens الضرب من اليسار G*A والضرب من اليمين مع النقل المرافق A*G'. لا يحتوي النوع على size، وبالتالي يمكن ضربه مع مصفوفات بحجم عشوائي طالما أن i2<=size(A,2) لـ G*A أو i2<=size(A,1) لـ A*G'.

انظر أيضًا givens.

givens(f::T, g::T, i1::Integer, i2::Integer) where {T} -> (G::Givens, r::T)

يحسب دوران غيفنز G والعدد السلمي r بحيث لأي متجه x حيث

x[i1] = f
x[i2] = g

نتيجة الضرب

y = G*x

لها الخاصية التي تجعل

y[i1] = r
y[i2] = 0

انظر أيضًا LinearAlgebra.Givens.

givens(A::AbstractArray, i1::Integer, i2::Integer, j::Integer) -> (G::Givens, r)

يحسب دوران غيفنز G والعدد السلمي r بحيث أن نتيجة الضرب

B = G*A

لها الخاصية التي تجعل

B[i1,j] = r
B[i2,j] = 0

انظر أيضًا LinearAlgebra.Givens.

givens(x::AbstractVector, i1::Integer, i2::Integer) -> (G::Givens, r)

يحسب دوران غيفنز G والعدد السلمي r بحيث أن نتيجة الضرب

B = G*x

تمتلك الخاصية التي تجعل

B[i1] = r
B[i2] = 0

انظر أيضًا LinearAlgebra.Givens.

triu(M)

مثلث علوي لمصفوفة.

أمثلة

julia> a = fill(1.0, (4,4))
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> triu(a)
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 0.0  1.0  1.0  1.0
 0.0  0.0  1.0  1.0
 0.0  0.0  0.0  1.0

triu(M, k::Integer)

إرجاع مثلث M العلوي بدءًا من السوبرقطر k.

أمثلة

julia> a = fill(1.0, (4,4))
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> triu(a,3)
4×4 Matrix{Float64}:
 0.0  0.0  0.0  1.0
 0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0

julia> triu(a,-3)
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

triu!(M)

مثلث علوي لمصفوفة، مع الكتابة فوق M في هذه العملية. انظر أيضًا triu.

triu!(M, k::Integer)

إرجاع مثلث M العلوي بدءًا من السوبرقطر k، مع الكتابة فوق M في هذه العملية.

أمثلة

julia> M = [1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5]
5×5 Matrix{Int64}:
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5

julia> triu!(M, 1)
5×5 Matrix{Int64}:
 0  2  3  4  5
 0  0  3  4  5
 0  0  0  4  5
 0  0  0  0  5
 0  0  0  0  0

tril(M)

مثلث سفلي لمصفوفة.

أمثلة

julia> a = fill(1.0, (4,4))
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> tril(a)
4×4 Matrix{Float64}:
 1.0  0.0  0.0  0.0
 1.0  1.0  0.0  0.0
 1.0  1.0  1.0  0.0
 1.0  1.0  1.0  1.0

tril(M, k::Integer)

إرجاع مثلث M السفلي بدءًا من السوبرقطر k.

أمثلة

julia> a = fill(1.0, (4,4))
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> tril(a,3)
4×4 Matrix{Float64}:
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0
 1.0  1.0  1.0  1.0

julia> tril(a,-3)
4×4 Matrix{Float64}:
 0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0
 0.0  0.0  0.0  0.0
 1.0  0.0  0.0  0.0

tril!(M)

مثلث سفلي لمصفوفة، مع الكتابة فوق M في هذه العملية. انظر أيضًا tril.

tril!(M, k::Integer)

إرجاع مثلث M السفلي بدءًا من k-th superdiagonal، مع الكتابة فوق M في هذه العملية.

أمثلة

julia> M = [1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5; 1 2 3 4 5]
5×5 Matrix{Int64}:
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5

julia> tril!(M, 2)
5×5 Matrix{Int64}:
 1  2  3  0  0
 1  2  3  4  0
 1  2  3  4  5
 1  2  3  4  5
 1  2  3  4  5

diagind(M::AbstractMatrix, k::Integer = 0, indstyle::IndexStyle = IndexLinear())
diagind(M::AbstractMatrix, indstyle::IndexStyle = IndexLinear())

نطاق AbstractRange يعطي مؤشرات القطر k للمصفوفة M. يمكن تحديد نمط الفهرسة اختياريًا والذي يحدد نوع النطاق المعاد. إذا كان indstyle isa IndexLinear (افتراضي)، فإن هذا يعيد AbstractRange{Integer}. من ناحية أخرى، إذا كان indstyle isa IndexCartesian، فإن هذا يعيد AbstractRange{CartesianIndex{2}}.

إذا لم يتم توفير k، يُفترض أن يكون 0 (الذي يتوافق مع القطر الرئيسي).

انظر أيضًا: diag, diagm, Diagonal.

أمثلة

julia> A = [1 2 3; 4 5 6; 7 8 9]
3×3 Matrix{Int64}:
 1  2  3
 4  5  6
 7  8  9

julia> diagind(A, -1)
2:4:6

julia> diagind(A, IndexCartesian())
StepRangeLen(CartesianIndex(1, 1), CartesianIndex(1, 1), 3)

diag(M, k::Integer=0)

القطر k لمصفوفة، كمتجه.

انظر أيضًا diagm، diagind، Diagonal، isdiag.

أمثلة

julia> A = [1 2 3; 4 5 6; 7 8 9]
3×3 Matrix{Int64}:
 1  2  3
 4  5  6
 7  8  9

julia> diag(A,1)
2-element Vector{Int64}:
 2
 6

diagm(kv::Pair{<:Integer,<:AbstractVector}...)
diagm(m::Integer, n::Integer, kv::Pair{<:Integer,<:AbstractVector}...)

قم بإنشاء مصفوفة من `Pair`s من القطرات والمتجهات. سيتم وضع المتجه `kv.second` على القطر `kv.first`. بشكل افتراضي، تكون المصفوفة مربعة وحجمها مستنتج من `kv`، ولكن يمكن تحديد حجم غير مربع `m`×`n` (مملوء بالصفر حسب الحاجة) عن طريق تمرير `m,n` كأول وسيطين. بالنسبة لمؤشرات القطر المتكررة `kv.first`، ستتم إضافة القيم في المتجهات المقابلة `kv.second`.

تقوم `diagm` بإنشاء مصفوفة كاملة؛ إذا كنت تريد إصدارات موفرة للتخزين مع حسابات سريعة، انظر إلى [`Diagonal`](@ref)، [`Bidiagonal`](@ref) [`Tridiagonal`](@ref) و [`SymTridiagonal`](@ref).

# أمثلة

jldoctest julia> diagm(1 => [1,2,3]) 4×4 Matrix{Int64}: 0 1 0 0 0 0 2 0 0 0 0 3 0 0 0 0

julia> diagm(1 => [1,2,3], -1 => [4,5]) 4×4 Matrix{Int64}: 0 1 0 0 4 0 2 0 0 5 0 3 0 0 0 0

julia> diagm(1 => [1,2,3], 1 => [1,2,3]) 4×4 Matrix{Int64}: 0 2 0 0 0 0 4 0 0 0 0 6 0 0 0 0 ```

diagm(v::AbstractVector)
diagm(m::Integer, n::Integer, v::AbstractVector)

قم بإنشاء مصفوفة تحتوي على عناصر المتجه كعناصر قطرية. بشكل افتراضي، تكون المصفوفة مربعة وحجمها محدد بواسطة length(v)، ولكن يمكن تحديد حجم غير مربع m×n عن طريق تمرير m,n كأول وسيطين.

أمثلة

julia> diagm([1,2,3])
3×3 Matrix{Int64}:
 1  0  0
 0  2  0
 0  0  3

rank(::QRSparse{Tv,Ti}) -> Ti

إرجاع رتبة تحليل QR

rank(S::SparseMatrixCSC{Tv,Ti}; [tol::Real]) -> Ti

احسب رتبة S عن طريق حساب تحليل QR الخاص به. تعتبر القيم الأصغر من tol صفرًا. انظر دليل SPQR.

rank(A::AbstractMatrix; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
rank(A::AbstractMatrix, rtol::Real)

احسب الرتبة العددية لمصفوفة عن طريق عد عدد المخرجات من svdvals(A) التي تكون أكبر من max(atol, rtol*σ₁) حيث σ₁ هو أكبر قيمة مفردة محسوبة لـ A. atol و rtol هما الحدود المطلقة والنسبية، على التوالي. الحد الافتراضي للنسبة هو n*ϵ، حيث n هو حجم أصغر بعد من A، و ϵ هو eps لنوع عنصر A.

!!! ملاحظة يمكن أن تكون الرتبة العددية وصفًا حساسًا وغير دقيق للمصفوفات ذات الحالة السيئة التي تحتوي على قيم مفردة قريبة من حد التسامح max(atol, rtol*σ₁). في مثل هذه الحالات، يمكن أن تؤدي التغيرات الطفيفة في حساب القيمة المفردة أو في المصفوفة إلى تغيير نتيجة rank عن طريق دفع واحدة أو أكثر من القيم المفردة عبر العتبة. يمكن أن تحدث هذه التغيرات حتى بسبب التغيرات في أخطاء النقطة العائمة بين إصدارات جوليا المختلفة، والهندسة المعمارية، والمجمعات، أو أنظمة التشغيل.

!!! توافق "جوليا 1.1" تتطلب وسائط الكلمات الرئيسية atol و rtol على الأقل جوليا 1.1. في جوليا 1.0، تتوفر rtol كوسيط موضعي، ولكن سيتم إهمال ذلك في جوليا 2.0.

أمثلة

julia> rank(Matrix(I, 3, 3))
3

julia> rank(diagm(0 => [1, 0, 2]))
2

julia> rank(diagm(0 => [1, 0.001, 2]), rtol=0.1)
2

julia> rank(diagm(0 => [1, 0.001, 2]), rtol=0.00001)
3

julia> rank(diagm(0 => [1, 0.001, 2]), atol=1.5)
1

norm(A, p::Real=2)

لأي حاوية قابلة للتكرار A (بما في ذلك المصفوفات من أي بعد) من الأرقام (أو أي نوع عنصر يتم تعريف norm له)، احسب p-norm (مع الافتراضي p=2) كما لو كانت A متجهًا بالطول المقابل.

يتم تعريف p-norm على أنه

\[\|A\|_p = \left( \sum_{i=1}^n | a_i | ^p \right)^{1/p}\]

حيث $a_i$ هي عناصر A، و$| a_i |$ هو norm لـ $a_i$، و$n$ هو طول A. نظرًا لأن p-norm يتم حسابه باستخدام norm لعناصر A، فإن p-norm لمتجه من المتجهات غير متوافق مع تفسيره كمتجه كتلة بشكل عام إذا كان p != 2.

يمكن أن يأخذ p أي قيمة عددية (على الرغم من أن ليس كل القيم تنتج معيار متجه رياضي صالح). على وجه الخصوص، norm(A, Inf) يعيد أكبر قيمة في abs.(A)، بينما norm(A, -Inf) يعيد أصغر قيمة. إذا كانت A مصفوفة وp=2، فإن هذا يعادل معيار فروبينياس.

الحجة الثانية p ليست بالضرورة جزءًا من واجهة norm، أي أن نوعًا مخصصًا قد ينفذ فقط norm(A) بدون حجة ثانية.

استخدم opnorm لحساب معيار المشغل لمصفوفة.

أمثلة

julia> v = [3, -2, 6]
3-element Vector{Int64}:
  3
 -2
  6

julia> norm(v)
7.0

julia> norm(v, 1)
11.0

julia> norm(v, Inf)
6.0

julia> norm([1 2 3; 4 5 6; 7 8 9])
16.881943016134134

julia> norm([1 2 3 4 5 6 7 8 9])
16.881943016134134

julia> norm(1:9)
16.881943016134134

julia> norm(hcat(v,v), 1) == norm(vcat(v,v), 1) != norm([v,v], 1)
true

julia> norm(hcat(v,v), 2) == norm(vcat(v,v), 2) == norm([v,v], 2)
true

julia> norm(hcat(v,v), Inf) == norm(vcat(v,v), Inf) != norm([v,v], Inf)
true

norm(x::Number, p::Real=2)

بالنسبة للأرقام، أعد $\left( |x|^p \right)^{1/p}$.

أمثلة

julia> norm(2, 1)
2.0

julia> norm(-2, 1)
2.0

julia> norm(2, 2)
2.0

julia> norm(-2, 2)
2.0

julia> norm(2, Inf)
2.0

julia> norm(-2, Inf)
2.0

opnorm(A::AbstractMatrix, p::Real=2)

احسب معيار المشغل (أو معيار المصفوفة) المستمد من معيار المتجه p، حيث القيم الصالحة لـ p هي 1، 2، أو Inf. (لاحظ أنه بالنسبة للمصفوفات المتناثرة، p=2 غير مُنفذ حاليًا.) استخدم norm لحساب معيار فروبيني.

عندما يكون p=1، يكون معيار المشغل هو الحد الأقصى لمجموع الأعمدة المطلقة لـ A:

\[\|A\|_1 = \max_{1 ≤ j ≤ n} \sum_{i=1}^m | a_{ij} |\]

حيث $a_{ij}$ هي عناصر A، و m و n هما أبعاده.

عندما يكون p=2، يكون معيار المشغل هو المعيار الطيفي، والذي يساوي أكبر قيمة مفردة لـ A.

عندما يكون p=Inf، يكون معيار المشغل هو الحد الأقصى لمجموع الصفوف المطلقة لـ A:

\[\|A\|_\infty = \max_{1 ≤ i ≤ m} \sum _{j=1}^n | a_{ij} |\]

أمثلة

julia> A = [1 -2 -3; 2 3 -1]
2×3 Matrix{Int64}:
 1  -2  -3
 2   3  -1

julia> opnorm(A, Inf)
6.0

julia> opnorm(A, 1)
5.0

opnorm(x::Number, p::Real=2)

بالنسبة للأرقام، أعد $\left( |x|^p \right)^{1/p}$. هذا يعادل norm.

opnorm(A::Adjoint{<:Any,<:AbstractVector}, q::Real=2)
opnorm(A::Transpose{<:Any,<:AbstractVector}, q::Real=2)

بالنسبة للمتجهات المغلفة بـ Adjoint/Transpose، قم بإرجاع معيار المشغل $q$-norm لـ A، والذي يعادل معيار p بقيمة p = q/(q-1). يتطابقان عند p = q = 2. استخدم norm لحساب معيار p لـ A كمتجه.

تنشأ الفروق في المعيار بين فضاء المتجهات وثنائيه للحفاظ على العلاقة بين الثنائيات والمنتج النقطي، والنتيجة متسقة مع معيار p-norm لمصفوفة 1 × n.

أمثلة

julia> v = [1; im];

julia> vc = v';

julia> opnorm(vc, 1)
1.0

julia> norm(vc, 1)
2.0

julia> norm(v, 1)
2.0

julia> opnorm(vc, 2)
1.4142135623730951

julia> norm(vc, 2)
1.4142135623730951

julia> norm(v, 2)
1.4142135623730951

julia> opnorm(vc, Inf)
2.0

julia> norm(vc, Inf)
1.0

julia> norm(v, Inf)
1.0

normalize!(a::AbstractArray, p::Real=2)

قم بتطبيع المصفوفة a في المكان بحيث يكون معيارها p يساوي الواحد، أي norm(a, p) == 1. انظر أيضًا normalize و norm.

normalize(a, p::Real=2)

قم بتطبيع a بحيث يكون p-norm يساوي الوحدة، أي norm(a, p) == 1. بالنسبة للأعداد، فإن هذا مشابه لـ sign(a)، باستثناء أن normalize(0) = NaN. انظر أيضًا normalize!، norm، و sign.

أمثلة

julia> a = [1,2,4];

julia> b = normalize(a)
3-element Vector{Float64}:
 0.2182178902359924
 0.4364357804719848
 0.8728715609439696

julia> norm(b)
1.0

julia> c = normalize(a, 1)
3-element Vector{Float64}:
 0.14285714285714285
 0.2857142857142857
 0.5714285714285714

julia> norm(c, 1)
1.0

julia> a = [1 2 4 ; 1 2 4]
2×3 Matrix{Int64}:
 1  2  4
 1  2  4

julia> norm(a)
6.48074069840786

julia> normalize(a)
2×3 Matrix{Float64}:
 0.154303  0.308607  0.617213
 0.154303  0.308607  0.617213

julia> normalize(3, 1)
1.0

julia> normalize(-8, 1)
-1.0

julia> normalize(0, 1)
NaN

cond(M, p::Real=2)

رقم الحالة للمصفوفة M، يتم حسابه باستخدام معيار p-norm. القيم الصالحة لـ p هي 1، 2 (افتراضي)، أو Inf.

condskeel(M, [x, p::Real=Inf])

\[\kappa_S(M, p) = \left\Vert \left\vert M \right\vert \left\vert M^{-1} \right\vert \right\Vert_p \\ \kappa_S(M, x, p) = \frac{\left\Vert \left\vert M \right\vert \left\vert M^{-1} \right\vert \left\vert x \right\vert \right\Vert_p}{\left \Vert x \right \Vert_p}\]

عدد حالة سكيل $\kappa_S$ للمصفوفة M، اختياريًا بالنسبة إلى المتجه x، كما تم حسابه باستخدام معيار المشغل p. $\left\vert M \right\vert$ يدل على مصفوفة القيم المطلقة (عنصرًا بعنصر) لـ $M$؛ $\left\vert M \right\vert_{ij} = \left\vert M_{ij} \right\vert$. القيم الصالحة لـ p هي 1، 2 و Inf (افتراضي).

تُعرف هذه الكمية أيضًا في الأدبيات باسم عدد حالة باور، عدد الحالة النسبي، أو عدد الحالة النسبي العنصري.

tr(M)

تتبع المصفوفة. يجمع العناصر القطرية لـ M.

أمثلة

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> tr(A)
5

det(M)

محدد المصفوفة.

انظر أيضًا: logdet و logabsdet.

أمثلة

julia> M = [1 0; 2 2]
2×2 Matrix{Int64}:
 1  0
 2  2

julia> det(M)
2.0

logdet(M)

لوغاريتم محدد المصفوفة. يعادل log(det(M))، ولكنه قد يوفر دقة أكبر ويتجنب overflow/underflow.

أمثلة

julia> M = [1 0; 2 2]
2×2 Matrix{Int64}:
 1  0
 2  2

julia> logdet(M)
0.6931471805599453

julia> logdet(Matrix(I, 3, 3))
0.0

logabsdet(M)

لوغاريتم القيمة المطلقة لمحدد المصفوفة. يعادل (log(abs(det(M))), sign(det(M)))، ولكنه قد يوفر دقة و/أو سرعة أكبر.

أمثلة

julia> A = [-1. 0.; 0. 1.]
2×2 Matrix{Float64}:
 -1.0  0.0
  0.0  1.0

julia> det(A)
-1.0

julia> logabsdet(A)
(0.0, -1.0)

julia> B = [2. 0.; 0. 1.]
2×2 Matrix{Float64}:
 2.0  0.0
 0.0  1.0

julia> det(B)
2.0

julia> logabsdet(B)
(0.6931471805599453, 1.0)

inv(M)

معكوس المصفوفة. يحسب المصفوفة N بحيث M * N = I، حيث I هي مصفوفة الهوية. يتم حسابها عن طريق حل القسمة اليسارية N = M \ I.

أمثلة

julia> M = [2 5; 1 3]
2×2 Matrix{Int64}:
 2  5
 1  3

julia> N = inv(M)
2×2 Matrix{Float64}:
  3.0  -5.0
 -1.0   2.0

julia> M*N == N*M == Matrix(I, 2, 2)
true

pinv(M; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
pinv(M, rtol::Real) = pinv(M; rtol=rtol) # to be deprecated in Julia 2.0

يحسب المعكوس الزائف لمور.

بالنسبة للمصفوفات M التي تحتوي على عناصر بنقطة عائمة، من الملائم حساب المعكوس الزائف عن طريق عكس القيم الفردية التي تزيد عن max(atol, rtol*σ₁) حيث σ₁ هو أكبر قيمة فردية لـ M.

يختلف الاختيار الأمثل للتسامح المطلق (atol) والتسامح النسبي (rtol) حسب قيمة M والتطبيق المقصود للمعكوس الزائف. التسامح النسبي الافتراضي هو n*ϵ، حيث n هو حجم أصغر بعد من M، و ϵ هو eps لنوع عنصر M.

للعكس في المصفوفات الكثيفة ذات الحالة السيئة بمعنى المربعات الصغرى، يُوصى باستخدام rtol = sqrt(eps(real(float(oneunit(eltype(M)))))).

لمزيد من المعلومات، انظر ^[issue8859], ^[B96], ^[S84], ^[KY88].

أمثلة

julia> M = [1.5 1.3; 1.2 1.9]
2×2 Matrix{Float64}:
 1.5  1.3
 1.2  1.9

julia> N = pinv(M)
2×2 Matrix{Float64}:
  1.47287   -1.00775
 -0.930233   1.16279

julia> M * N
2×2 Matrix{Float64}:
 1.0          -2.22045e-16
 4.44089e-16   1.0

nullspace(M; atol::Real=0, rtol::Real=atol>0 ? 0 : n*ϵ)
nullspace(M, rtol::Real) = nullspace(M; rtol=rtol) # to be deprecated in Julia 2.0

يحسب قاعدة للفضاء الصفري لـ `M` من خلال تضمين المتجهات الفردية لـ `M` التي لها قيم فردية ذات مقادير أصغر من `max(atol, rtol*σ₁)`، حيث `σ₁` هو أكبر قيمة فردية لـ `M`.

بشكل افتراضي، فإن التسامح النسبي `rtol` هو `n*ϵ`، حيث `n` هو حجم أصغر بعد من `M`، و `ϵ` هو [`eps`](@ref) لنوع عنصر `M`.

# أمثلة

jldoctest julia> M = [1 0 0; 0 1 0; 0 0 0] 3×3 Matrix{Int64}: 1 0 0 0 1 0 0 0 0

julia> nullspace(M) 3×1 Matrix{Float64}: 0.0 0.0 1.0

julia> nullspace(M, rtol=3) 3×3 Matrix{Float64}: 0.0 1.0 0.0 1.0 0.0 0.0 0.0 0.0 1.0

julia> nullspace(M, atol=0.95) 3×1 Matrix{Float64}: 0.0 0.0 1.0 ```

kron(A, B)

يحسب حاصل ضرب كرونكر لعددين أو مصفوفتين أو متجهين.

بالنسبة للمتجهات الحقيقية v و w، يرتبط حاصل ضرب كرونكر بالضرب الخارجي بواسطة kron(v,w) == vec(w * transpose(v)) أو w * transpose(v) == reshape(kron(v,w), (length(w), length(v))). لاحظ كيف يختلف ترتيب v و w على اليسار واليمين من هذه التعبيرات (بسبب تخزين الأعمدة). بالنسبة للمتجهات المعقدة، يختلف الضرب الخارجي w * v' أيضًا من خلال الاقتران لـ v.

أمثلة

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> B = [im 1; 1 -im]
2×2 Matrix{Complex{Int64}}:
 0+1im  1+0im
 1+0im  0-1im

julia> kron(A, B)
4×4 Matrix{Complex{Int64}}:
 0+1im  1+0im  0+2im  2+0im
 1+0im  0-1im  2+0im  0-2im
 0+3im  3+0im  0+4im  4+0im
 3+0im  0-3im  4+0im  0-4im

julia> v = [1, 2]; w = [3, 4, 5];

julia> w*transpose(v)
3×2 Matrix{Int64}:
 3   6
 4   8
 5  10

julia> reshape(kron(v,w), (length(w), length(v)))
3×2 Matrix{Int64}:
 3   6
 4   8
 5  10

kron!(C, A, B)

يحسب حاصل ضرب كرونكر لـ A و B ويخزن النتيجة في C، مما يؤدي إلى الكتابة فوق المحتوى الحالي لـ C. هذه هي النسخة في المكان من kron.

exp(A::AbstractMatrix)

احسب الأسية المصفوفية لـ A، المعرفة بواسطة

\[e^A = \sum_{n=0}^{\infty} \frac{A^n}{n!}.\]

بالنسبة لـ A المتماثلة أو هيرميتية، يتم استخدام تحليل القيم الذاتية (eigen)، وإلا يتم اختيار خوارزمية التوسيع والتربيع (انظر ^[H05]).

أمثلة

julia> A = Matrix(1.0I, 2, 2)
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0

julia> exp(A)
2×2 Matrix{Float64}:
 2.71828  0.0
 0.0      2.71828

cis(A::AbstractMatrix)

طريقة أكثر كفاءة لـ exp(im*A) لمصفوفة مربعة A (خصوصًا إذا كانت A هرميتية أو متماثلة حقيقية).

انظر أيضًا cispi, sincos, exp.

أمثلة

julia> cis([π 0; 0 π]) ≈ -I
true

^(A::AbstractMatrix, p::Number)

قوة المصفوفة، تعادل $\exp(p\log(A))$

أمثلة

julia> [1 2; 0 3]^3
2×2 Matrix{Int64}:
 1  26
 0  27

^(b::Number, A::AbstractMatrix)

الأس exponential للمصفوفة، يعادل $\exp(\log(b)A)$.

أمثلة

julia> 2^[1 2; 0 3]
2×2 Matrix{Float64}:
 2.0  6.0
 0.0  8.0

julia> ℯ^[1 2; 0 3]
2×2 Matrix{Float64}:
 2.71828  17.3673
 0.0      20.0855

log(A::AbstractMatrix)

إذا كانت A لا تحتوي على قيمة ذاتية حقيقية سالبة، احسب اللوغاريتم الرئيسي للمصفوفة لـ A، أي المصفوفة الفريدة $X$ بحيث $e^X = A$ و $-\pi < Im(\lambda) < \pi$ لجميع القيم الذاتية $\lambda$ لـ $X$. إذا كانت A تحتوي على قيم ذاتية غير موجبة، يتم إرجاع دالة مصفوفة غير رئيسية كلما كان ذلك ممكنًا.

إذا كانت A متناظرة أو هيرميتية، يتم استخدام تحليل القيم الذاتية لها (eigen)، إذا كانت A مثلثية، يتم استخدام نسخة محسنة من طريقة التحجيم العكسي والتربيع (انظر ^[AH12] و ^[AHR13]). إذا كانت A حقيقية ولا تحتوي على قيم ذاتية سالبة، يتم حساب الشكل الشرّي الحقيقي. خلاف ذلك، يتم حساب الشكل الشرّي المعقد. ثم يتم استخدام خوارزمية (شبه) مثلثية علوية في ^[AHR13] على العامل (شبه) المثلثي العلوي.

أمثلة

julia> A = Matrix(2.7182818*I, 2, 2)
2×2 Matrix{Float64}:
 2.71828  0.0
 0.0      2.71828

julia> log(A)
2×2 Matrix{Float64}:
 1.0  0.0
 0.0  1.0

√(x)

ارجع $\sqrt{x}$.

يرمي DomainError للوسائط السلبية من نوع Real. استخدم الوسائط السلبية المعقدة بدلاً من ذلك. لاحظ أن sqrt لديه قطع فرعي على المحور الحقيقي السالب.

المشغل البادئ √ يعادل sqrt.

انظر أيضًا: hypot.

أمثلة

julia> sqrt(big(81))
9.0

julia> sqrt(big(-81))
ERROR: DomainError with -81.0:
NaN result for non-NaN input.
Stacktrace:
 [1] sqrt(::BigFloat) at ./mpfr.jl:501
[...]

julia> sqrt(big(complex(-81)))
0.0 + 9.0im

julia> sqrt(-81 - 0.0im)  # -0.0im هو أدنى من القطع الفرعي
0.0 - 9.0im

julia> .√(1:4)
4-element Vector{Float64}:
 1.0
 1.4142135623730951
 1.7320508075688772
 2.0

sqrt(A::AbstractMatrix)

إذا كانت A لا تحتوي على قيم ذاتية حقيقية سالبة، احسب الجذر التربيعي الرئيسي للمصفوفة A، وهو المصفوفة الفريدة $X$ التي تحتوي على قيم ذاتية لها جزء حقيقي موجب بحيث $X^2 = A$. خلاف ذلك، يتم إرجاع جذر تربيعي غير رئيسي.

إذا كانت A متناسقة حقيقية أو هيرميتية، يتم استخدام تحليل القيم الذاتية (eigen) لحساب الجذر التربيعي. بالنسبة لمثل هذه المصفوفات، يتم التعامل مع القيم الذاتية λ التي تبدو سالبة قليلاً بسبب أخطاء التقريب كما لو كانت صفرًا. بشكل أكثر دقة، يتم اعتبار المصفوفات التي تحتوي على جميع القيم الذاتية ≥ -rtol*(max |λ|) على أنها شبه محددة (مما يؤدي إلى جذر هيرميتي)، مع اعتبار القيم الذاتية السالبة صفرًا. rtol هو وسيط كلمة رئيسية لـ sqrt (في حالة الهيرميتية/المتناسقة الحقيقية فقط) الذي يتم تعيينه افتراضيًا إلى دقة الآلة مضروبة في size(A,1).

خلاف ذلك، يتم تحديد الجذر التربيعي بواسطة طريقة بيورك-هامارلينغ ^[BH83]، التي تحسب الشكل الشوري المعقد (schur) ثم الجذر التربيعي المعقد للعامل المثلثي. إذا كان هناك جذر تربيعي حقيقي، يتم استخدام امتداد لهذه الطريقة ^[H87] التي تحسب الشكل الشوري الحقيقي ثم الجذر التربيعي الحقيقي للعامل شبه المثلثي.

أمثلة

julia> A = [4 0; 0 4]
2×2 Matrix{Int64}:
 4  0
 0  4

julia> sqrt(A)
2×2 Matrix{Float64}:
 2.0  0.0
 0.0  2.0

cbrt(A::AbstractMatrix{<:Real})

يحسب الجذر التكعيبي الحقيقي لمصفوفة حقيقية A. إذا كانت T = cbrt(A)، فإننا نحصل على T*T*T ≈ A، انظر المثال المعطى أدناه.

إذا كانت A متناظرة، أي من النوع HermOrSym{<:Real}، فإن (eigen) تُستخدم لإيجاد الجذر التكعيبي. خلاف ذلك، يتم استخدام نسخة متخصصة من خوارزمية الجذر p-th ^[S03]، والتي تستغل تحليل شير الحقيقي (schur) لحساب الجذر التكعيبي.

أمثلة

julia> A = [0.927524 -0.15857; -1.3677 -1.01172]
2×2 Matrix{Float64}:
  0.927524  -0.15857
 -1.3677    -1.01172

julia> T = cbrt(A)
2×2 Matrix{Float64}:
  0.910077  -0.151019
 -1.30257   -0.936818

julia> T*T*T ≈ A
true

cos(A::AbstractMatrix)

احسب جيب التمام لمصفوفة مربعة A.

إذا كانت A متناظرة أو هيرميتية، يتم استخدام تحليل القيم الذاتية (eigen) لحساب جيب التمام. خلاف ذلك، يتم تحديد جيب التمام عن طريق استدعاء exp.

أمثلة

julia> cos(fill(1.0, (2,2)))
2×2 Matrix{Float64}:
  0.291927  -0.708073
 -0.708073   0.291927

sin(A::AbstractMatrix)

احسب جيب الزاوية لمصفوفة مربعة A.

إذا كانت A متناظرة أو هيرميتية، يتم استخدام تحليل القيم الذاتية لها (eigen) لحساب الجيب. خلاف ذلك، يتم تحديد الجيب عن طريق استدعاء exp.

أمثلة

julia> sin(fill(1.0, (2,2)))
2×2 Matrix{Float64}:
 0.454649  0.454649
 0.454649  0.454649

sincos(A::AbstractMatrix)

احسب جيب الزاوية وجيب التمام لمصفوفة مربعة A.

أمثلة

julia> S, C = sincos(fill(1.0, (2,2)));

julia> S
2×2 Matrix{Float64}:
 0.454649  0.454649
 0.454649  0.454649

julia> C
2×2 Matrix{Float64}:
  0.291927  -0.708073
 -0.708073   0.291927

tan(A::AbstractMatrix)

احسب ظل المصفوفة لمصفوفة مربعة A.

إذا كانت A متناظرة أو هيرميتية، يتم استخدام تحليل القيم الذاتية لها (eigen) لحساب الظل. خلاف ذلك، يتم تحديد الظل عن طريق استدعاء exp.

أمثلة

julia> tan(fill(1.0, (2,2)))
2×2 Matrix{Float64}:
 -1.09252  -1.09252
 -1.09252  -1.09252

sec(A::AbstractMatrix)

احسب المماس الثانوي للمصفوفة المربعة A.

csc(A::AbstractMatrix)

احسب كوسكانت المصفوفة لمصفوفة مربعة A.

cot(A::AbstractMatrix)

احسب ظل المصفوفة لمصفوفة مربعة A.

cosh(A::AbstractMatrix)

احسب جيب التمام الزائدي لمصفوفة مربعة A.

sinh(A::AbstractMatrix)

احسب جيب الزاوية الزائدية للمصفوفة لمصفوفة مربعة A.

tanh(A::AbstractMatrix)

احسب تانجنط المصفوفة الزائدية لمصفوفة مربعة A.

sech(A::AbstractMatrix)

احسب القاطع الزائد المصفوفي لمصفوفة مربعة A.

csch(A::AbstractMatrix)

احسب الكوسيك الهبرولي للمصفوفة للمصفوفة التربيعية A.

coth(A::AbstractMatrix)

احسب قاطع الزاوية المصفوفي الهبرولي للمصفوفة المربعة A.

acos(A::AbstractMatrix)

احسب كوساين المصفوفة العكسية لمصفوفة مربعة A.

إذا كانت A متناظرة أو هيرميتية، يتم استخدام تحليل القيم الذاتية لها (eigen) لحساب كوساين العكس. خلاف ذلك، يتم تحديد كوساين العكس باستخدام log و sqrt. للحصول على النظرية والصيغ اللوغاريتمية المستخدمة لحساب هذه الدالة، انظر ^[AH16_1].

أمثلة

julia> acos(cos([0.5 0.1; -0.2 0.3]))
2×2 Matrix{ComplexF64}:
  0.5-8.32667e-17im  0.1+0.0im
 -0.2+2.63678e-16im  0.3-3.46945e-16im

asin(A::AbstractMatrix)

احسب دالة الجيب العكسية لمصفوفة مربعة A.

إذا كانت A متناظرة أو هيرميتية، يتم استخدام تحليل القيم الذاتية (eigen) لحساب دالة الجيب العكسية. خلاف ذلك، يتم تحديد دالة الجيب العكسية باستخدام log و sqrt. لنظرية والصيغ اللوغاريتمية المستخدمة لحساب هذه الدالة، انظر ^[AH16_2].

أمثلة

julia> asin(sin([0.5 0.1; -0.2 0.3]))
2×2 Matrix{ComplexF64}:
  0.5-4.16334e-17im  0.1-5.55112e-17im
 -0.2+9.71445e-17im  0.3-1.249e-16im

atan(A::AbstractMatrix)

احسب ظل المصفوفة العكسية لمصفوفة مربعة A.

إذا كانت A متناظرة أو هيرميتية، يتم استخدام تحليل القيم الذاتية (eigen) لحساب ظل العكس. خلاف ذلك، يتم تحديد ظل العكس باستخدام log. للحصول على النظرية والصيغ اللوغاريتمية المستخدمة لحساب هذه الدالة، انظر ^[AH16_3].

أمثلة

julia> atan(tan([0.5 0.1; -0.2 0.3]))
2×2 Matrix{ComplexF64}:
  0.5+1.38778e-17im  0.1-2.77556e-17im
 -0.2+6.93889e-17im  0.3-4.16334e-17im

asec(A::AbstractMatrix)

احسب مصفوفة القاطع العكسية لـ A.

acsc(A::AbstractMatrix)

احسب قاطع المصفوفة العكسية لـ A.

acot(A::AbstractMatrix)

احسب المصفوفة العكسية للقطان من A.

acosh(A::AbstractMatrix)

احسب كوساين المصفوفة العكسية الزائدية لمصفوفة مربعة A. بالنسبة للنظرية والصيغ اللوغاريتمية المستخدمة لحساب هذه الدالة، انظر ^[AH16_4].

asinh(A::AbstractMatrix)

احسب دالة الجيب الزائدي العكسية لمصفوفة مربعة A. بالنسبة للنظرية والصيغ اللوغاريتمية المستخدمة لحساب هذه الدالة، انظر ^[AH16_5].

atanh(A::AbstractMatrix)

احسب المماس العكسي الزائد لمصفوفة مربعة A. للنظرية والصيغ اللوغاريتمية المستخدمة لحساب هذه الدالة، انظر ^[AH16_6].

asech(A::AbstractMatrix)

احسب المصفوفة العكسية للسيكانت الزائد لـ A.

acsch(A::AbstractMatrix)

احسب قاطع الزاوية المقلوب الهبرولي لـ A.

acoth(A::AbstractMatrix)

احسب القاطع الزائد العكسي للمصفوفة A.

lyap(A, C)

يحسب الحل X لمعادلة ليابونوف المستمرة AX + XA' + C = 0، حيث لا يوجد قيمة ذاتية لـ A لها جزء حقيقي يساوي صفر ولا يوجد قيمتان ذاتيتان هما أعداد مركبة سالبة مترافقة مع بعضها البعض.

أمثلة

julia> A = [3. 4.; 5. 6]
2×2 Matrix{Float64}:
 3.0  4.0
 5.0  6.0

julia> B = [1. 1.; 1. 2.]
2×2 Matrix{Float64}:
 1.0  1.0
 1.0  2.0

julia> X = lyap(A, B)
2×2 Matrix{Float64}:
  0.5  -0.5
 -0.5   0.25

julia> A*X + X*A' ≈ -B
true

sylvester(A, B, C)

يحسب الحل X لمعادلة سيلفستر AX + XB + C = 0، حيث أن A و B و C لها أبعاد متوافقة و A و -B ليس لهما قيم ذاتية لها نفس الجزء الحقيقي.

أمثلة

julia> A = [3. 4.; 5. 6]
2×2 Matrix{Float64}:
 3.0  4.0
 5.0  6.0

julia> B = [1. 1.; 1. 2.]
2×2 Matrix{Float64}:
 1.0  1.0
 1.0  2.0

julia> C = [1. 2.; -2. 1]
2×2 Matrix{Float64}:
  1.0  2.0
 -2.0  1.0

julia> X = sylvester(A, B, C)
2×2 Matrix{Float64}:
 -4.46667   1.93333
  3.73333  -1.8

julia> A*X + X*B ≈ -C
true

issuccess(F::Factorization)

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

أمثلة

julia> F = cholesky([1 0; 0 1]);

julia> issuccess(F)
true

issuccess(F::LU; allowsingular = false)

اختبر ما إذا كانت عملية التحليل LU لمصفوفة ما قد نجحت. بشكل افتراضي، تعتبر عملية التحليل التي تنتج عامل U صالح ولكن ناقص الرتبة فاشلة. يمكن تغيير ذلك عن طريق تمرير allowsingular = true.

أمثلة

julia> F = lu([1 2; 1 2], check = false);

julia> issuccess(F)
false

julia> issuccess(F, allowsingular = true)
true

issymmetric(A) -> Bool

اختبر ما إذا كانت المصفوفة متناظرة.

أمثلة

julia> a = [1 2; 2 -1]
2×2 Matrix{Int64}:
 1   2
 2  -1

julia> issymmetric(a)
true

julia> b = [1 im; -im 1]
2×2 Matrix{Complex{Int64}}:
 1+0im  0+1im
 0-1im  1+0im

julia> issymmetric(b)
false

isposdef(A) -> Bool

اختبر ما إذا كانت المصفوفة إيجابية محددة (وهرميتية) من خلال محاولة إجراء تحليل شولي (Cholesky) لـ A.

انظر أيضًا isposdef!، cholesky.

أمثلة

julia> A = [1 2; 2 50]
2×2 Matrix{Int64}:
 1   2
 2  50

julia> isposdef(A)
true

isposdef!(A) -> Bool

اختبر ما إذا كانت المصفوفة إيجابية محددة (وهرميتية) من خلال محاولة إجراء تحليل شولي (Cholesky) لـ A، مع الكتابة فوق A في هذه العملية. انظر أيضًا isposdef.

أمثلة

julia> A = [1. 2.; 2. 50.];

julia> isposdef!(A)
true

julia> A
2×2 Matrix{Float64}:
 1.0  2.0
 2.0  6.78233

istril(A::AbstractMatrix, k::Integer = 0) -> Bool

اختبر ما إذا كانت A مثلثية سفلية بدءًا من السوبرقطر k.

أمثلة

julia> a = [1 2; 2 -1]
2×2 Matrix{Int64}:
 1   2
 2  -1

julia> istril(a)
false

julia> istril(a, 1)
true

julia> c = [1 1 0; 1 1 1; 1 1 1]
3×3 Matrix{Int64}:
 1  1  0
 1  1  1
 1  1  1

julia> istril(c)
false

julia> istril(c, 1)
true

istriu(A::AbstractMatrix, k::Integer = 0) -> Bool

اختبر ما إذا كانت A مثلثية علوية بدءًا من السوبرقطر k.

أمثلة

julia> a = [1 2; 2 -1]
2×2 Matrix{Int64}:
 1   2
 2  -1

julia> istriu(a)
false

julia> istriu(a, -1)
true

julia> c = [1 1 1; 1 1 1; 0 1 1]
3×3 Matrix{Int64}:
 1  1  1
 1  1  1
 0  1  1

julia> istriu(c)
false

julia> istriu(c, -1)
true

isdiag(A) -> Bool

اختبر ما إذا كانت المصفوفة قطرية بمعنى أن iszero(A[i,j]) صحيح ما لم يكن i == j. لاحظ أنه ليس من الضروري أن تكون A مربعة؛ إذا كنت ترغب أيضًا في التحقق من ذلك، تحتاج إلى التحقق من أن size(A, 1) == size(A, 2).

أمثلة

julia> a = [1 2; 2 -1]
2×2 Matrix{Int64}:
 1   2
 2  -1

julia> isdiag(a)
false

julia> b = [im 0; 0 -im]
2×2 Matrix{Complex{Int64}}:
 0+1im  0+0im
 0+0im  0-1im

julia> isdiag(b)
true

julia> c = [1 0 0; 0 2 0]
2×3 Matrix{Int64}:
 1  0  0
 0  2  0

julia> isdiag(c)
true

julia> d = [1 0 0; 0 2 3]
2×3 Matrix{Int64}:
 1  0  0
 0  2  3

julia> isdiag(d)
false

ishermitian(A) -> Bool

اختبر ما إذا كانت المصفوفة هيرميتية.

أمثلة

julia> a = [1 2; 2 -1]
2×2 Matrix{Int64}:
 1   2
 2  -1

julia> ishermitian(a)
true

julia> b = [1 im; -im 1]
2×2 Matrix{Complex{Int64}}:
 1+0im  0+1im
 0-1im  1+0im

julia> ishermitian(b)
true

transpose(A)

التحويل الكسري. يجب أن تؤدي التعديلات على الكائن المعاد إلى تعديل A بشكل مناسب. غالبًا، ولكن ليس دائمًا، ينتج Transpose(A)، حيث أن Transpose هو غلاف تحويل كسري. لاحظ أن هذه العملية متكررة.

تهدف هذه العملية للاستخدام في الجبر الخطي - لرؤية معالجة البيانات العامة، انظر permutedims، والتي ليست متكررة.

أمثلة

julia> A = [3 2; 0 0]
2×2 Matrix{Int64}:
 3  2
 0  0

julia> B = transpose(A)
2×2 transpose(::Matrix{Int64}) with eltype Int64:
 3  0
 2  0

julia> B isa Transpose
true

julia> transpose(B) === A # تحويل التحويل إلى تحويل يفتح الأصل
true

julia> Transpose(B) # ومع ذلك، فإن المنشئ دائمًا يلف حجته
2×2 transpose(transpose(::Matrix{Int64})) with eltype Int64:
 3  2
 0  0

julia> B[1,2] = 4; # تعديل B سيعدل A تلقائيًا

julia> A
2×2 Matrix{Int64}:
 3  2
 4  0

بالنسبة للمصفوفات المعقدة، فإن عملية adjoint تعادل التحويل المرافق.

julia> A = reshape([Complex(x, x) for x in 1:4], 2, 2)
2×2 Matrix{Complex{Int64}}:
 1+1im  3+3im
 2+2im  4+4im

julia> adjoint(A) == conj(transpose(A))
true

التحويل الكسري لـ AbstractVector هو متجه صف:

julia> v = [1,2,3]
3-element Vector{Int64}:
 1
 2
 3

julia> transpose(v) # يعيد متجه صف
1×3 transpose(::Vector{Int64}) with eltype Int64:
 1  2  3

julia> transpose(v) * v # حساب حاصل الضرب النقطي
14

بالنسبة لمصفوفة من المصفوفات، يتم تشغيل الكتل الفردية بشكل متكرر:

julia> C = [1 3; 2 4]
2×2 Matrix{Int64}:
 1  3
 2  4

julia> D = reshape([C, 2C, 3C, 4C], 2, 2) # بناء مصفوفة كتلية
2×2 Matrix{Matrix{Int64}}:
 [1 3; 2 4]  [3 9; 6 12]
 [2 6; 4 8]  [4 12; 8 16]

julia> transpose(D) # يتم تحويل الكتل بشكل متكرر
2×2 transpose(::Matrix{Matrix{Int64}}) with eltype Transpose{Int64, Matrix{Int64}}:
 [1 2; 3 4]   [2 4; 6 8]
 [3 6; 9 12]  [4 8; 12 16]

transpose(F::Factorization)

التحويل الكسري الكسول للعامل F. بشكل افتراضي، يُرجع TransposeFactorization، باستثناء Factorizations التي تحتوي على eltype حقيقي، حيث يُرجع AdjointFactorization.

transpose!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) where {Tv,Ti}

قم بنقل المصفوفة A وتخزينها في المصفوفة X. يجب أن يكون size(X) مساوياً لـ size(transpose(A)). لا يتم تخصيص أي ذاكرة إضافية بخلاف تغيير حجم rowval و nzval لـ X، إذا لزم الأمر.

انظر halfperm!

transpose!(dest,src)

قم بنقل مصفوفة src وتخزين النتيجة في المصفوفة المخصصة مسبقًا dest، والتي يجب أن يكون لها حجم يتوافق مع (size(src,2),size(src,1)). لا يتم دعم النقل في المكان، وستحدث نتائج غير متوقعة إذا كانت src و dest لهما مناطق ذاكرة متداخلة.

أمثلة

julia> A = [3+2im 9+2im; 8+7im  4+6im]
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

julia> B = zeros(Complex{Int64}, 2, 2)
2×2 Matrix{Complex{Int64}}:
 0+0im  0+0im
 0+0im  0+0im

julia> transpose!(B, A);

julia> B
2×2 Matrix{Complex{Int64}}:
 3+2im  8+7im
 9+2im  4+6im

julia> A
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

المصفوفة المنقولة

نوع غلاف كسول لعرض منقول للكائن الأساسي في الجبر الخطي، عادةً ما يكون AbstractVector/AbstractMatrix. عادةً، لا ينبغي استدعاء مُنشئ Transpose مباشرةً، استخدم transpose بدلاً من ذلك. لتجسيد العرض، استخدم copy.

هذا النوع مخصص للاستخدام في الجبر الخطي - لرؤية معالجة البيانات العامة، انظر permutedims.

أمثلة

julia> A = [2 3; 0 0]
2×2 Matrix{Int64}:
 2  3
 0  0

julia> Transpose(A)
2×2 transpose(::Matrix{Int64}) with eltype Int64:
 2  0
 3  0

TransposeFactorization

نوع غلاف كسول لمصفوفة النقل لكائن Factorization الأساسي. عادةً، يجب عدم استدعاء مُنشئ TransposeFactorization مباشرةً، استخدم transpose(:: Factorization) بدلاً من ذلك.

A'
adjoint(A)

المرافق الكسري (التحويل المعقد). لاحظ أن adjoint يتم تطبيقه بشكل متكرر على العناصر.

بالنسبة لأنواع الأعداد، فإن adjoint يعيد المرافق المعقد، وبالتالي فهو يعادل دالة الهوية للأعداد الحقيقية.

هذه العملية مخصصة لاستخدام الجبر الخطي - لرؤية معالجة البيانات العامة، انظر permutedims.

أمثلة

julia> A = [3+2im 9+2im; 0  0]
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 0+0im  0+0im

julia> B = A' # يعادل adjoint(A)
2×2 adjoint(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 3-2im  0+0im
 9-2im  0+0im

julia> B isa Adjoint
true

julia> adjoint(B) === A # المرافق لمرافق يفك الوالد
true

julia> Adjoint(B) # ومع ذلك، فإن المنشئ دائمًا يلف حجته
2×2 adjoint(adjoint(::Matrix{Complex{Int64}})) with eltype Complex{Int64}:
 3+2im  9+2im
 0+0im  0+0im

julia> B[1,2] = 4 + 5im; # تعديل B سيعدل A تلقائيًا

julia> A
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 4-5im  0+0im

بالنسبة للمصفوفات الحقيقية، فإن عملية adjoint تعادل transpose.

julia> A = reshape([x for x in 1:4], 2, 2)
2×2 Matrix{Int64}:
 1  3
 2  4

julia> A'
2×2 adjoint(::Matrix{Int64}) with eltype Int64:
 1  2
 3  4

julia> adjoint(A) == transpose(A)
true

المرافق لـ AbstractVector هو متجه صف:

julia> x = [3, 4im]
2-element Vector{Complex{Int64}}:
 3 + 0im
 0 + 4im

julia> x'
1×2 adjoint(::Vector{Complex{Int64}}) with eltype Complex{Int64}:
 3+0im  0-4im

julia> x'x # حساب حاصل الضرب النقطي، يعادل x' * x
25 + 0im

بالنسبة لمصفوفة من المصفوفات، يتم تشغيل الكتل الفردية بشكل متكرر:

julia> A = reshape([x + im*x for x in 1:4], 2, 2)
2×2 Matrix{Complex{Int64}}:
 1+1im  3+3im
 2+2im  4+4im

julia> C = reshape([A, 2A, 3A, 4A], 2, 2)
2×2 Matrix{Matrix{Complex{Int64}}}:
 [1+1im 3+3im; 2+2im 4+4im]  [3+3im 9+9im; 6+6im 12+12im]
 [2+2im 6+6im; 4+4im 8+8im]  [4+4im 12+12im; 8+8im 16+16im]

julia> C'
2×2 adjoint(::Matrix{Matrix{Complex{Int64}}}) with eltype Adjoint{Complex{Int64}, Matrix{Complex{Int64}}}:
 [1-1im 2-2im; 3-3im 4-4im]    [2-2im 4-4im; 6-6im 8-8im]
 [3-3im 6-6im; 9-9im 12-12im]  [4-4im 8-8im; 12-12im 16-16im]

adjoint(F::Factorization)

المرافق الكسول للعامل F. بشكل افتراضي، يُرجع غلاف AdjointFactorization.

adjoint!(X::AbstractSparseMatrixCSC{Tv,Ti}, A::AbstractSparseMatrixCSC{Tv,Ti}) where {Tv,Ti}

قم بنقل مصفوفة A وتخزين المرافق لعناصر المصفوفة X. يجب أن تكون size(X) مساوية لـ size(transpose(A)). لا يتم تخصيص أي ذاكرة إضافية بخلاف تغيير حجم rowval و nzval لـ X، إذا لزم الأمر.

انظر halfperm!

adjoint!(dest,src)

مصفوفة النقل المرافق src وتخزين النتيجة في المصفوفة المخصصة مسبقًا dest، والتي يجب أن يكون لها حجم يتوافق مع (size(src,2),size(src,1)). لا يتم دعم النقل في المكان، وستحدث نتائج غير متوقعة إذا كانت src و dest لهما مناطق ذاكرة متداخلة.

أمثلة

julia> A = [3+2im 9+2im; 8+7im  4+6im]
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

julia> B = zeros(Complex{Int64}, 2, 2)
2×2 Matrix{Complex{Int64}}:
 0+0im  0+0im
 0+0im  0+0im

julia> adjoint!(B, A);

julia> B
2×2 Matrix{Complex{Int64}}:
 3-2im  8-7im
 9-2im  4-6im

julia> A
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 8+7im  4+6im

المرافق

نوع لفافة كسولة لعرض المرافق للكائن الأساسي في الجبر الخطي، عادةً ما يكون AbstractVector/AbstractMatrix. عادةً، يجب عدم استدعاء مُنشئ Adjoint مباشرةً، استخدم adjoint بدلاً من ذلك. لتجسيد العرض، استخدم copy.

هذا النوع مخصص للاستخدام في الجبر الخطي - لرؤية معالجة البيانات العامة، انظر permutedims.

أمثلة

julia> A = [3+2im 9+2im; 0 0]
2×2 Matrix{Complex{Int64}}:
 3+2im  9+2im
 0+0im  0+0im

julia> Adjoint(A)
2×2 adjoint(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 3-2im  0+0im
 9-2im  0+0im

AdjointFactorization

نوع غلاف كسول لمرافق كائن Factorization الأساسي. عادةً، يجب عدم استدعاء مُنشئ AdjointFactorization مباشرةً، استخدم adjoint(:: Factorization) بدلاً من ذلك.

copy(A::Transpose)
copy(A::Adjoint)

قم بتقييم المصفوفة المنقولة/المرافقة الكسولة بشغف. لاحظ أن النقل يتم تطبيقه بشكل متكرر على العناصر.

تُستخدم هذه العملية في الجبر الخطي - لرؤية معالجة البيانات العامة، انظر permutedims، والتي ليست متكررة.

أمثلة

julia> A = [1 2im; -3im 4]
2×2 Matrix{Complex{Int64}}:
 1+0im  0+2im
 0-3im  4+0im

julia> T = transpose(A)
2×2 transpose(::Matrix{Complex{Int64}}) with eltype Complex{Int64}:
 1+0im  0-3im
 0+2im  4+0im

julia> copy(T)
2×2 Matrix{Complex{Int64}}:
 1+0im  0-3im
 0+2im  4+0im

stride1(A) -> Int

ارجع المسافة بين عناصر المصفوفة المتعاقبة في البعد 1 بوحدات حجم العنصر.

أمثلة

julia> A = [1,2,3,4]
4-element Vector{Int64}:
 1
 2
 3
 4

julia> LinearAlgebra.stride1(A)
1

julia> B = view(A, 2:2:4)
2-element view(::Vector{Int64}, 2:2:4) with eltype Int64:
 2
 4

julia> LinearAlgebra.stride1(B)
2

LinearAlgebra.checksquare(A)

تحقق من أن المصفوفة مربعة، ثم أعد بعددها المشترك. بالنسبة للوسائط المتعددة، أعد متجهًا.

أمثلة

julia> A = fill(1, (4,4)); B = fill(1, (5,5));

julia> LinearAlgebra.checksquare(A, B)
2-element Vector{Int64}:
 4
 5

LinearAlgebra.peakflops(n::Integer=4096; eltype::DataType=Float64, ntrials::Integer=3, parallel::Bool=false)

peakflops تحسب معدل الفلوبات الأقصى للكمبيوتر باستخدام دقة مزدوجة gemm!. بشكل افتراضي، إذا لم يتم تحديد أي معلمات، فإنها تضرب مصفوفتين من نوع Float64 بحجم n x n، حيث n = 4096. إذا كانت مكتبة BLAS الأساسية تستخدم خيوط متعددة، يتم تحقيق معدلات فلوبات أعلى. يمكن تعيين عدد خيوط BLAS باستخدام BLAS.set_num_threads(n).

إذا تم توفير معلمة الكلمة الرئيسية eltype، فإن peakflops ستقوم بإنشاء مصفوفات بعناصر من نوع eltype لحساب معدل الفلوبات الأقصى.

بشكل افتراضي، ستستخدم peakflops أفضل توقيت من 3 تجارب. إذا تم توفير معلمة الكلمة الرئيسية ntrials، ستستخدم peakflops هذا العدد من التجارب لاختيار أفضل توقيت.

إذا تم تعيين معلمة الكلمة الرئيسية parallel إلى true، يتم تشغيل peakflops بالتوازي على جميع معالجات العمال. يتم إرجاع معدل الفلوبات للكمبيوتر المتوازي بالكامل. عند التشغيل بالتوازي، يتم استخدام خيط واحد فقط من BLAS. لا يزال يشير المعامل n إلى حجم المشكلة التي يتم حلها على كل معالج.

hermitianpart(A::AbstractMatrix, uplo::Symbol=:U) -> Hermitian

ارجع الجزء الهيرميتي من المصفوفة المربعة A، والذي يُعرف بأنه (A + A') / 2، كمصفوفة Hermitian. بالنسبة للمصفوفات الحقيقية A، يُعرف هذا أيضًا بالجزء المتماثل من A؛ وأحيانًا يُطلق عليه "الجزء الحقيقي للمعامل". يتحكم الوسيط الاختياري uplo في الوسيط المقابل لعرض Hermitian. بالنسبة للمصفوفات الحقيقية، فإن الأخير يعادل عرض Symmetric.

انظر أيضًا hermitianpart! للعملية المقابلة في المكان.

hermitianpart!(A::AbstractMatrix, uplo::Symbol=:U) -> Hermitian

قم بكتابة مصفوفة A المربعة في مكانها مع جزء هيرميتيك الخاص بها (A + A') / 2، وأعد Hermitian(A, uplo). بالنسبة للمصفوفات الحقيقية A، يُعرف هذا أيضًا باسم الجزء المتماثل من A.

انظر أيضًا hermitianpart للعملية المقابلة خارج المكان.

copy_adjoint!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
                A::AbstractVecOrMat, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) -> B

نسخ عناصر المصفوفة A إلى B بكفاءة مع الترافق كما يلي:

B[ir_dest, jr_dest] = adjoint(A)[jr_src, ir_src]

يتم الكتابة فوق العناصر B[ir_dest, jr_dest]. علاوة على ذلك، يجب أن تلبي معلمات نطاق الفهرس length(ir_dest) == length(jr_src) و length(jr_dest) == length(ir_src).

copy_transpose!(B::AbstractVecOrMat, ir_dest::AbstractRange{Int}, jr_dest::AbstractRange{Int},
                A::AbstractVecOrMat, ir_src::AbstractRange{Int}, jr_src::AbstractRange{Int}) -> B

نسخ عناصر المصفوفة A إلى B بكفاءة مع النقل كما يلي:

B[ir_dest, jr_dest] = transpose(A)[jr_src, ir_src]

يتم الكتابة فوق العناصر B[ir_dest, jr_dest]. علاوة على ذلك، يجب أن تلبي معلمات نطاق الفهرس length(ir_dest) == length(jr_src) و length(jr_dest) == length(ir_src).

copy_transpose!(B::AbstractMatrix, ir_dest::AbstractUnitRange, jr_dest::AbstractUnitRange,
                tM::AbstractChar,
                M::AbstractVecOrMat, ir_src::AbstractUnitRange, jr_src::AbstractUnitRange) -> B

نسخ عناصر المصفوفة M بكفاءة إلى B مشروطًا على معلمة الحرف tM كما يلي:

يتم الكتابة فوق العناصر B[ir_dest, jr_dest]. علاوة على ذلك، يجب أن تلبي معلمات نطاق الفهرس الشرط length(ir_dest) == length(jr_src) و length(jr_dest) == length(ir_src).

انظر أيضًا copyto! و copy_adjoint!.

mul!(Y, A, B) -> Y

يحسب حاصل ضرب المصفوفة-المصفوفة أو المصفوفة-المتجه $A B$ ويخزن النتيجة في Y، مما يؤدي إلى الكتابة فوق القيمة الحالية لـ Y. لاحظ أن Y يجب ألا يكون متماثلاً مع أي من A أو B.

أمثلة

julia> A = [1.0 2.0; 3.0 4.0]; B = [1.0 1.0; 1.0 1.0]; Y = similar(B);

julia> mul!(Y, A, B) === Y
true

julia> Y
2×2 Matrix{Float64}:
 3.0  3.0
 7.0  7.0

julia> Y == A * B
true

التنفيذ

بالنسبة لأنواع المصفوفات والمتجهات المخصصة، يُوصى بتنفيذ mul! ذات 5 معطيات بدلاً من تنفيذ mul! ذات 3 معطيات مباشرة إذا كان ذلك ممكنًا.

mul!(C, A, B, α, β) -> C

عملية ضرب-إضافة مصفوفة-مصفوفة أو مصفوفة-متجه في المكان $A B α + C β$. يتم تخزين النتيجة في C عن طريق الكتابة فوقها. لاحظ أن C يجب ألا تكون مرتبطة بأي من A أو B.

أمثلة

julia> A = [1.0 2.0; 3.0 4.0]; B = [1.0 1.0; 1.0 1.0]; C = [1.0 2.0; 3.0 4.0];

julia> α, β = 100.0, 10.0;

julia> mul!(C, A, B, α, β) === C
true

julia> C
2×2 Matrix{Float64}:
 310.0  320.0
 730.0  740.0

julia> C_original = [1.0 2.0; 3.0 4.0]; # نسخة من القيمة الأصلية لـ C

julia> C == A * B * α + C_original * β
true

lmul!(a::Number, B::AbstractArray)

قم بتوسيع مصفوفة B بواسطة عدد حقيقي a مع الكتابة فوق B في المكان. استخدم rmul! لضرب العدد من اليمين. عملية التوسيع تحترم دلالات الضرب * بين a وعنصر من B. بشكل خاص، ينطبق هذا أيضًا على الضرب الذي يتضمن أعداد غير نهائية مثل NaN و ±Inf.

أمثلة

julia> B = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> lmul!(2, B)
2×2 Matrix{Int64}:
 2  4
 6  8

julia> lmul!(0.0, [Inf])
1-element Vector{Float64}:
 NaN

lmul!(A, B)

احسب حاصل ضرب المصفوفتين $AB$، مع الكتابة فوق B، وأعد النتيجة. هنا، يجب أن تكون A من نوع مصفوفة خاص، مثل، على سبيل المثال، Diagonal، UpperTriangular أو LowerTriangular، أو من نوع متعامد ما، انظر QR.

أمثلة

julia> B = [0 1; 1 0];

julia> A = UpperTriangular([1 2; 0 3]);

julia> lmul!(A, B);

julia> B
2×2 Matrix{Int64}:
 2  1
 3  0

julia> B = [1.0 2.0; 3.0 4.0];

julia> F = qr([0 1; -1 0]);

julia> lmul!(F.Q, B)
2×2 Matrix{Float64}:
 3.0  4.0
 1.0  2.0

rmul!(A::AbstractArray, b::Number)

قم بتعديل مصفوفة A بواسطة عدد b مع الكتابة فوق A في المكان. استخدم lmul! لضرب العدد من اليسار. تحترم عملية التعديل دلالات الضرب * بين عنصر من A و b. بشكل خاص، ينطبق هذا أيضًا على الضرب الذي يتضمن أعداد غير نهائية مثل NaN و ±Inf.

أمثلة

julia> A = [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

julia> rmul!(A, 2)
2×2 Matrix{Int64}:
 2  4
 6  8

julia> rmul!([NaN], 0.0)
1-element Vector{Float64}:
 NaN

rmul!(A, B)

احسب حاصل ضرب المصفوفتين $AB$، مع الكتابة فوق A، وأعد النتيجة. هنا، يجب أن تكون B من نوع مصفوفة خاص، مثل، على سبيل المثال، Diagonal، UpperTriangular أو LowerTriangular، أو من نوع متعامد ما، انظر QR.

أمثلة

julia> A = [0 1; 1 0];

julia> B = UpperTriangular([1 2; 0 3]);

julia> rmul!(A, B);

julia> A
2×2 Matrix{Int64}:
 0  3
 1  2

julia> A = [1.0 2.0; 3.0 4.0];

julia> F = qr([0 1; -1 0]);

julia> rmul!(A, F.Q)
2×2 Matrix{Float64}:
 2.0  1.0
 4.0  3.0

ldiv!(Y, A, B) -> Y

احسب A \ B في المكان واحتفظ بالنتيجة في Y، مع إرجاع النتيجة.

يجب أن لا يكون الوسيط A مصفوفة. بدلاً من ذلك، يجب أن يكون كائن تحليل (على سبيل المثال، تم إنتاجه بواسطة factorize أو cholesky). السبب في ذلك هو أن التحليل نفسه مكلف وعادة ما يخصص الذاكرة (على الرغم من أنه يمكن أيضًا القيام به في المكان عبر، على سبيل المثال، lu!)، والمواقف الحرجة من حيث الأداء التي تتطلب ldiv! عادة ما تتطلب أيضًا تحكمًا دقيقًا في تحليل A.

!!! ملاحظة أنواع المصفوفات الهيكلية معينة، مثل Diagonal و UpperTriangular، مسموح بها، حيث إنها بالفعل في شكل محلل

أمثلة

julia> A = [1 2.2 4; 3.1 0.2 3; 4 1 2];

julia> X = [1; 2.5; 3];

julia> Y = zero(X);

julia> ldiv!(Y, qr(A), X);

julia> Y ≈ A\X
true

ldiv!(A, B)

احسب A \ B في المكان مع الكتابة فوق B لتخزين النتيجة.

يجب أن تكون الحجة A ليست مصفوفة. بدلاً من المصفوفات، يجب أن تكون كائن تحليل (مثل الذي يتم إنتاجه بواسطة factorize أو cholesky). السبب في ذلك هو أن التحليل نفسه مكلف وعادة ما يخصص الذاكرة (على الرغم من أنه يمكن أيضًا القيام به في المكان عبر، على سبيل المثال، lu!)، والمواقف الحرجة من حيث الأداء التي تتطلب ldiv! عادة ما تتطلب أيضًا تحكمًا دقيقًا في تحليل A.

!!! ملاحظة بعض أنواع المصفوفات الهيكلية، مثل Diagonal و UpperTriangular، مسموح بها، حيث إنها بالفعل في شكل محلل

أمثلة

julia> A = [1 2.2 4; 3.1 0.2 3; 4 1 2];

julia> X = [1; 2.5; 3];

julia> Y = copy(X);

julia> ldiv!(qr(A), X);

julia> X ≈ A\Y
true

ldiv!(a::Number, B::AbstractArray)

قسّم كل عنصر في مصفوفة B على عدد a مع الكتابة فوق B في المكان. استخدم rdiv! لقسمة العدد من اليمين.

أمثلة

julia> B = [1.0 2.0; 3.0 4.0]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> ldiv!(2.0, B)
2×2 Matrix{Float64}:
 0.5  1.0
 1.5  2.0

ldiv!(A::Tridiagonal, B::AbstractVecOrMat) -> B

احسب A \ B في المكان عن طريق الحذف الغاوسي مع التدوير الجزئي واحتفظ بالنتيجة في B، مع إرجاع النتيجة. في هذه العملية، يتم الكتابة فوق الأقطار لـ A أيضًا.

rdiv!(A, B)

احسب A / B في المكان وبدلاً من ذلك قم بكتابة النتيجة في A.

يجب أن لا يكون الوسيط B مصفوفة. بدلاً من ذلك، يجب أن يكون كائن تحليل (على سبيل المثال، تم إنتاجه بواسطة factorize أو cholesky). السبب في ذلك هو أن التحليل نفسه مكلف وعادة ما يخصص الذاكرة (على الرغم من أنه يمكن أيضًا القيام به في المكان عبر، على سبيل المثال، lu!)، والمواقف الحرجة من حيث الأداء التي تتطلب rdiv! تتطلب عادةً أيضًا تحكمًا دقيقًا في تحليل B.

!!! ملاحظة يُسمح بأنواع المصفوفات الهيكلية معينة، مثل Diagonal و UpperTriangular، حيث إنها بالفعل في شكل محلل.

rdiv!(A::AbstractArray, b::Number)

قسّم كل عنصر في مصفوفة A على عدد b مع الكتابة فوق A في المكان. استخدم ldiv! لقسمة العدد من اليسار.

أمثلة

julia> A = [1.0 2.0; 3.0 4.0]
2×2 Matrix{Float64}:
 1.0  2.0
 3.0  4.0

julia> rdiv!(A, 2.0)
2×2 Matrix{Float64}:
 0.5  1.0
 1.5  2.0

واجهة لاستدعاءات BLAS.

set_num_threads(n::Integer)
set_num_threads(::Nothing)

قم بتعيين عدد الخيوط التي يجب أن تستخدمها مكتبة BLAS لتكون مساوية لـ n::Integer.

كما يقبل nothing، وفي هذه الحالة تحاول جوليا تخمين العدد الافتراضي للخيوط. يُنصح بعدم تمرير nothing وهو موجود بشكل أساسي لأسباب تاريخية.

get_num_threads()

احصل على عدد الخيوط التي تستخدمها مكتبة BLAS.

rot!(n, X, incx, Y, incy, c, s)

استبدل X بـ c*X + s*Y و Y بـ -conj(s)*X + c*Y لأول n عنصر من مصفوفة X بخطوة incx وأول n عنصر من مصفوفة Y بخطوة incy. يُرجع X و Y.

scal!(n, a, X, incx)
scal!(a, X)

استبدل X بـ a*X لأول n عنصر من مصفوفة X مع خطوة incx. يُرجع X.

إذا لم يتم توفير n و incx، يتم استخدام length(X) و stride(X,1).

scal(n, a, X, incx)
scal(a, X)

إرجاع X مضروبًا في a لأول n عناصر من المصفوفة X مع خطوة incx.

إذا لم يتم توفير n و incx، يتم استخدام length(X) و stride(X,1).

blascopy!(n, X, incx, Y, incy)

انسخ n عنصرًا من المصفوفة X مع خطوة incx إلى المصفوفة Y مع خطوة incy. يُرجع Y.

dot(n, X, incx, Y, incy)

حاصل الضرب النقطي لاثنين من المتجهات التي تتكون من n عنصر من المصفوفة X مع خطوة incx و n عنصر من المصفوفة Y مع خطوة incy.

أمثلة

julia> BLAS.dot(10, fill(1.0, 10), 1, fill(1.0, 20), 2)
10.0

dotu(n, X, incx, Y, incy)

دالة النقطة لاثنين من المتجهات المعقدة تتكون من n عنصر من المصفوفة X مع خطوة incx و n عنصر من المصفوفة Y مع خطوة incy.

أمثلة

julia> BLAS.dotu(10, fill(1.0im, 10), 1, fill(1.0+im, 20), 2)
-10.0 + 10.0im

dotc(n, X, incx, U, incy)

دالة النقطة لمتجهين مركبين، تتكون من n عنصر من المصفوفة X مع خطوة incx و n عنصر من المصفوفة U مع خطوة incy، مع مراعاة المرافق للمتجه الأول.

أمثلة

julia> BLAS.dotc(10, fill(1.0im, 10), 1, fill(1.0+im, 20), 2)
10.0 - 10.0im

nrm2(n, X, incx)

2-nورم لفيكتور يتكون من n عناصر من المصفوفة X مع خطوة incx.

أمثلة

julia> BLAS.nrm2(4, fill(1.0, 8), 2)
2.0

julia> BLAS.nrm2(1, fill(1.0, 8), 2)
1.0

asum(n, X, incx)

مجموع القيم المطلقة لأول n عنصر من مصفوفة X مع خطوة incx.

بالنسبة لمصفوفة حقيقية، القيمة المطلقة هي القيمة المطلقة. بالنسبة لمصفوفة معقدة، القيمة المطلقة هي مجموع القيمة المطلقة للجزء الحقيقي والقيمة المطلقة للجزء التخيلي.

أمثلة

julia> BLAS.asum(5, fill(1.0im, 10), 2)
5.0

julia> BLAS.asum(2, fill(1.0im, 10), 5)
2.0

iamax(n, dx, incx)
iamax(dx)

ابحث عن فهرس العنصر في dx الذي له أقصى قيمة مطلقة. n هو طول dx، و incx هو الخطوة. إذا لم يتم توفير n و incx، فإنهما يفترضان قيم افتراضية لـ n=length(dx) و incx=stride1(dx).

gemv!(tA, alpha, A, x, beta, y)

قم بتحديث المتجه y كالتالي alpha*A*x + beta*y أو alpha*A'x + beta*y وفقًا لـ tA. alpha و beta هما عددان حقيقيان. أعد المتجه y المحدث.

gemv(tA, alpha, A, x)

إرجاع alpha*A*x أو alpha*A'x وفقًا لـ tA. alpha هو عدد حقيقي.

gemv(tA, A, x)

إرجاع A*x أو A'x وفقًا لـ tA.

gbmv!(trans, m, kl, ku, alpha, A, x, beta, y)

قم بتحديث المتجه y كالتالي alpha*A*x + beta*y أو alpha*A'*x + beta*y وفقًا لـ trans. المصفوفة A هي مصفوفة شريطية عامة بأبعاد m بواسطة size(A,2) مع kl تحت القطر و ku فوق القطر. alpha و beta هما عددان حقيقيان. أعد المتجه y المحدث.

gbmv(trans, m, kl, ku, alpha, A, x)

إرجاع alpha*A*x أو alpha*A'*x وفقًا لـ trans. المصفوفة A هي مصفوفة شريطية عامة بأبعاد m بواسطة size(A,2) مع kl تحت القطر و ku فوق القطر، و alpha هو عدد حقيقي.

hemv!(ul, alpha, A, x, beta, y)

قم بتحديث المتجه y كالتالي alpha*A*x + beta*y. يُفترض أن تكون A هيرميتية. يتم استخدام فقط مثلث ul من A. alpha و beta هما عددان حقيقيان. أعد المتجه y المحدث.

hemv(ul, alpha, A, x)

إرجاع alpha*A*x. يُفترض أن تكون A هيرميتية. يتم استخدام فقط مثلث ul من A. alpha هو عدد حقيقي.

hemv(ul, A, x)

إرجاع A*x. يُفترض أن تكون A هيرميتية. يتم استخدام فقط مثلث ul من A.

hpmv!(uplo, α, AP, x, β, y)

قم بتحديث المتجه y كالتالي α*A*x + β*y، حيث A هو مصفوفة هيرميتية مقدمة بتنسيق مضغوط AP.

مع uplo = 'U'، يجب أن يحتوي المصفوفة AP على الجزء العلوي المثلث من المصفوفة الهيرميتية مضغوطًا بالتتابع، عمودًا بعمود، بحيث يحتوي AP[1] على A[1, 1]، و AP[2] و AP[3] يحتويان على A[1, 2] و A[2, 2] على التوالي، وهكذا.

مع uplo = 'L'، يجب أن يحتوي المصفوفة AP على الجزء السفلي المثلث من المصفوفة الهيرميتية مضغوطًا بالتتابع، عمودًا بعمود، بحيث يحتوي AP[1] على A[1, 1]، و AP[2] و AP[3] يحتويان على A[2, 1] و A[3, 1] على التوالي، وهكذا.

يجب أن تكون المدخلات العددية α و β أعدادًا مركبة أو حقيقية.

يجب أن تكون المدخلات المصفوفية x و y و AP جميعها من نوع ComplexF32 أو ComplexF64.

أعد y المحدثة.

symv!(ul, alpha, A, x, beta, y)

قم بتحديث المتجه y كالتالي alpha*A*x + beta*y. يُفترض أن تكون A متماثلة. يتم استخدام فقط مثلث ul من A. alpha و beta هما عددان حقيقيان. أعد المتجه y المحدث.

symv(ul, alpha, A, x)

إرجاع alpha*A*x. يُفترض أن تكون A متماثلة. يتم استخدام فقط مثلث ul من A. alpha هو عدد حقيقي.

symv(ul, A, x)

إرجاع A*x. يُفترض أن تكون A متناظرة. يتم استخدام فقط مثلث ul من A.

sbmv!(uplo, k, alpha, A, x, beta, y)

قم بتحديث المتجه y كالتالي alpha*A*x + beta*y حيث أن A هو مصفوفة band متناظرة من الرتبة size(A,2) مع k فوق القطر المخزن في الوسيطة A. يتم وصف تخزين A في مرجع وحدة BLAS، BLAS من المستوى 2 على https://www.netlib.org/lapack/explore-html/. يتم استخدام فقط مثلث uplo من A.

أعد المتجه y المحدث.

sbmv(uplo, k, alpha, A, x)

إرجاع alpha*A*x حيث أن A هو مصفوفة band متناظرة من الرتبة size(A,2) مع k فوق القطر المخزن في الوسيطة A. يتم استخدام فقط مثلث uplo من A.

sbmv(uplo, k, A, x)

إرجاع A*x حيث أن A هو مصفوفة band متناظرة من الرتبة size(A,2) مع k فوق القطر المخزن في الوسيطة A. يتم استخدام فقط مثلث uplo من A.

spmv!(uplo, α, AP, x, β, y)

قم بتحديث المتجه y كالتالي α*A*x + β*y، حيث A هو مصفوفة متناظرة مقدمة بتنسيق مضغوط AP.

مع uplo = 'U'، يجب أن يحتوي المصفوفة AP على الجزء العلوي المثلث من المصفوفة المتناظرة مضغوطًا بالتتابع، عمودًا بعمود، بحيث يحتوي AP[1] على A[1, 1]، و AP[2] و AP[3] يحتويان على A[1, 2] و A[2, 2] على التوالي، وهكذا.

مع uplo = 'L'، يجب أن يحتوي المصفوفة AP على الجزء السفلي المثلث من المصفوفة المتناظرة مضغوطًا بالتتابع، عمودًا بعمود، بحيث يحتوي AP[1] على A[1, 1]، و AP[2] و AP[3] يحتويان على A[2, 1] و A[3, 1] على التوالي، وهكذا.

يجب أن تكون المدخلات العددية α و β حقيقية.

يجب أن تكون المدخلات المصفوفية x و y و AP جميعها من نوع Float32 أو Float64.

أعد y المحدثة.

trmv!(ul, tA, dA, A, b)

إرجاع op(A)*b، حيث يتم تحديد op بواسطة tA. يتم استخدام مثلث ul فقط من A. تحدد dA ما إذا كانت قيم القطر تُقرأ أو يُفترض أن تكون جميعها واحدة. تحدث عملية الضرب في المكان على b.

trmv(ul, tA, dA, A, b)

إرجاع op(A)*b، حيث يتم تحديد op بواسطة tA. يتم استخدام مثلث ul فقط من A. تحدد dA ما إذا كانت القيم القطرية تُقرأ أو يُفترض أنها جميعها واحدة.

trsv!(ul, tA, dA, A, b)

استبدل b بالحل لـ A*x = b أو أحد النسخ الأخرى المحددة بواسطة tA و ul. تحدد dA ما إذا كانت القيم القطرية تُقرأ أو يُفترض أنها جميعها واحدة. أعد القيمة المحدثة لـ b.

trsv(ul, tA, dA, A, b)

ارجع الحل لـ A*x = b أو أحد النسخ الأخرى المحددة بواسطة tA و ul. dA يحدد ما إذا كانت القيم القطرية تُقرأ أو يُفترض أنها جميعها واحدة.

ger!(alpha, x, y, A)

تحديث من الرتبة 1 للمصفوفة A باستخدام المتجهات x و y كـ alpha*x*y' + A.

her!(uplo, alpha, x, A)

طرق لمصفوفات معقدة فقط. تحديث من الرتبة 1 لمصفوفة هيرميتية A مع المتجه x كـ alpha*x*x' + A. uplo يتحكم في أي مثلث من A يتم تحديثه. تعيد A.

syr!(uplo, alpha, x, A)

تحديث من الرتبة 1 للمصفوفة المتماثلة A مع المتجه x كـ alpha*x*transpose(x) + A. uplo يتحكم في أي مثلث من A يتم تحديثه. تعيد A.

spr!(uplo, α, x, AP)

تحديث المصفوفة A كـ A+α*x*x'، حيث A هي مصفوفة متناظرة مقدمة بتنسيق مضغوط AP و x هو متجه.

مع uplo = 'U'، يجب أن يحتوي المصفوفة AP على الجزء العلوي المثلث من المصفوفة المتناظرة مضغوطًا بالتتابع، عمودًا بعمود، بحيث يحتوي AP[1] على A[1, 1]، و AP[2] و AP[3] يحتويان على A[1, 2] و A[2, 2] على التوالي، وهكذا.

مع uplo = 'L'، يجب أن يحتوي المصفوفة AP على الجزء السفلي المثلث من المصفوفة المتناظرة مضغوطًا بالتتابع، عمودًا بعمود، بحيث يحتوي AP[1] على A[1, 1]، و AP[2] و AP[3] يحتويان على A[2, 1] و A[3, 1] على التوالي، وهكذا.

يجب أن يكون الإدخال الاسكالي α حقيقيًا.

يجب أن تكون المدخلات المصفوفية x و AP جميعها من نوع Float32 أو Float64. ارجع إلى AP المحدثة.

gemmt!(uplo, tA, tB, alpha, A, B, beta, C)

قم بتحديث الجزء المثلثي السفلي أو العلوي المحدد بواسطة uplo من C كـ alpha*A*B + beta*C أو المتغيرات الأخرى وفقًا لـ tA و tB. أعد C المحدثة.

gemmt(uplo, tA, tB, alpha, A, B)

إرجاع الجزء المثلثي السفلي أو العلوي المحدد بواسطة uplo من A*B أو الثلاثة متغيرات الأخرى وفقًا لـ tA و tB.

gemmt(uplo, tA, tB, A, B)

إرجاع الجزء المثلثي السفلي أو العلوي المحدد بواسطة uplo من A*B أو الثلاثة متغيرات الأخرى وفقًا لـ tA و tB.

gemm!(tA, tB, alpha, A, B, beta, C)

قم بتحديث C كـ alpha*A*B + beta*C أو الثلاثة متغيرات الأخرى وفقًا لـ tA و tB. أعد C المحدثة.

gemm(tA, tB, alpha, A, B)

إرجاع alpha*A*B أو الثلاثة متغيرات الأخرى وفقًا لـ tA و tB.

gemm(tA, tB, A, B)

إرجاع A*B أو الثلاثة متغيرات الأخرى وفقًا لـ tA و tB.

symm!(side, ul, alpha, A, B, beta, C)

قم بتحديث C كالتالي alpha*A*B + beta*C أو alpha*B*A + beta*C وفقًا لـ side. يُفترض أن تكون A متماثلة. يتم استخدام فقط مثلث ul من A. أعد C المحدثة.

symm(side, ul, alpha, A, B)

إرجاع alpha*A*B أو alpha*B*A وفقًا لـ side. يُفترض أن تكون A متناظرة. يتم استخدام فقط مثلث ul من A.

symm(side, ul, A, B)

إرجاع A*B أو B*A وفقًا لـ side. يُفترض أن تكون A متناظرة. يتم استخدام فقط مثلث ul من A.