↖️ 🤢 👻 रैखिक बीजगणित के सिद्धांत से मैट्रिस के साथ काम करने के एक उदाहरण के रूप में कार्यात्मक प्रोग्रामिंग 🎧 🍟 ♂️

परिचय

मैट्रिसेस के साथ काम करने का आधार (इस लेख में हम केवल दो आयामी मैट्रिसेस पर विचार करेंगे) रैखिक बीजगणित के क्षेत्र से एक शक्तिशाली गणितीय सिद्धांत है। एक परिभाषा या कार्रवाई दूसरे से होती है, एक फ़ंक्शन दूसरे को कॉल करता है। इसलिए, मैट्रिस पर गणितीय कार्यों के कार्यात्मक के कार्यात्मक कार्यान्वयन के लिए, कार्यात्मक भाषाएं बहुत अच्छी तरह से फिट होती हैं। इस लेख में, हम एफ # में विशिष्ट उदाहरणों को देखेंगे और इस पर विस्तृत टिप्पणी देंगे कि यह कैसे काम करता है। चूंकि F # .NET परिवार का हिस्सा है, इसलिए परिणामस्वरूप कार्यक्षमता का उपयोग अन्य अनिवार्य भाषाओं में बिना किसी समस्या के किया जा सकता है, उदाहरण के लिए C #।

मैट्रिक्स की परिभाषा और एफ # में कार्यान्वयन

मैट्रीज रैखिक बीजगणित का मूल और सबसे महत्वपूर्ण हिस्सा हैं। मैट्रिसेस का उपयोग अक्सर प्रोग्रामिंग में किया जाता है, उदाहरण के लिए, 3 डी मॉडलिंग या गेम डेवलपमेंट में। बेशक, साइकिल का आविष्कार लंबे समय से किया गया है और मैट्रिस के साथ काम करने के लिए आवश्यक रूपरेखा पहले से ही तैयार हैं, और उनका उपयोग किया जाना चाहिए। यह लेख एक नई रूपरेखा का आविष्कार करने के उद्देश्य से नहीं है, लेकिन एफ # प्रोग्रामिंग भाषा का उपयोग करके कार्यात्मक शैली में मैट्रिसेस के साथ काम करने के लिए बुनियादी गणितीय कार्यों के कार्यान्वयन को दर्शाता है। जैसा कि हम सामग्री की जांच करते हैं, हम गणित के गणितीय सिद्धांत की ओर मुड़ेंगे और देखेंगे कि इसे कोड में कैसे लागू किया जा सकता है।

सबसे पहले, आइए याद करें कि मैट्रिक्स क्या है? थ्योरी हमें निम्नलिखित बताती है

M पंक्तियों और n स्तंभों वाली संख्याओं का एक आयताकार तालिका आकार mxn का एक मैट्रिक्स कहलाता है

मैट्रिसेस को आमतौर पर लैटिन वर्णमाला के बड़े अक्षरों द्वारा दर्शाया जाता है और इसे लिखा जाता है

A = (\begin{matrix} a 11 & a 12 & . . . & a 1 n \\ a 21 & a 22 & . . . & a 2 n \\ . . . & . . . & . . . & . . . \\ a m 1 & a m 2 & . . . & a m n \end{matrix})

$A=\begin{pmatrix}a11&a12&...&a1n\\a21&a22&...&a2n\\...&...&...&...\\am1&am2&...&amn\end{pmatrix}$

या शीघ्र ही

A = (a i j)

$A=(aij)$

एफ # में मैट्रिसेस के साथ काम करने के लिए हम एक दो-आयामी तालिका के आधार पर एक रिकॉर्ड बनाएंगे, जिसे हम उस पर आवश्यक गणितीय कार्यों को करने के लिए उपयोगी तरीकों के साथ आगे विस्तार करेंगे।

type Matrix = { values: int[,] }
    with
        //    
    end

द्वि-आयामी सरणी के साथ रिकॉर्डिंग को प्रारंभ करने के लिए एक सहायक विधि जोड़ें

static member ofArray2D (values: int [,]) = 
    { values = values }

फ़ंक्शन के लिए इनपुट तर्क एक दो-आयामी सरणी होगा, और इसके आउटपुट पर, मैट्रिक्स का एक रिकॉर्ड होगा । नीचे रिकॉर्ड आरंभीकरण का एक उदाहरण है।

let a = array2D [[1;0;2]
                 [3;1;0]]
let A = Matrix.ofArray2D a

दो मेट्रिसेस A = (aij) और B = (bij) को समतुल्य कहा जाता है यदि वे तत्ववाचक संयोग करते हैं, अर्थात aij = bij for all i = 1,2 ..., m और j = 1,2 ... n

इस नियम को लागू करने के लिए, हम ओवरराइड ऑपरेटर == का उपयोग करेंगे और कुछ उपयोगी कार्यों को जोड़ेंगे, जिनकी हमें भविष्य में भी आवश्यकता होगी।

static member sizes matrix =
    let rows = matrix.values.[*,0].Length
    let cols = matrix.values.[0,*].Length
    (rows, cols)

static member isEquallySized matrix1 matrix2 =
    let dim1 = Matrix.sizes matrix1
    let dim2 = Matrix.sizes matrix2
    (dim1 = dim2)

static member (==) (matrix1, matrix2) =
    if not (Matrix.isEquallySized matrix1 matrix2) then false
    else
        not (matrix1.values
               |> Array2D.mapi (fun x y v -> if matrix2.values.[x, y] <> v then false else true)
               |> Seq.cast<bool>
               |> Seq.contains false)

चलो ऊपर दिए गए कोड पर एक करीब से नज़र डालें। जैसा कि आप देख सकते हैं, तीन कार्य हैं। पहला आकार फ़ंक्शन मैट्रिक्स के आयाम को टपल के रूप में लौटाता है। चूंकि हम केवल आयताकार मैट्रिक्स के साथ काम करते हैं, पंक्तियों की संख्या प्राप्त करने के लिए, हम पहले कॉलम का पूरा टुकड़ा लेते हैं और अपनी लंबाई वापस करते हैं।

let rows = matrix.values.[*,0].Length

स्तंभों की संख्या एक समान तरीके से निर्धारित करना - हमें पहली पंक्ति का एक पूरा टुकड़ा मिलता है और इसकी लंबाई वापस आती है।

निम्नलिखित isEquallySized समारोह दो मैट्रिक्स के आयाम तुलना करता है और रिटर्न सच अगर वे बराबर हैं। ऐसा करने के लिए, यह तैयार-किए गए आकारों के फ़ंक्शन का उपयोग करता है और बस परिणामों की तुलना करता है। == दो तत्वों की तुलना करने वाले तत्व के लिए

ऑपरेटर अधिक जटिल लगता है, लेकिन अब आप देखेंगे कि यह भी सरल है। दो मैट्रिक्स की तुलना करने से पहले, हम उनके आयाम की तुलना करते हैं। यदि वे समान नहीं हैं, तो जाँच का कोई मतलब नहीं है, क्योंकि यह पहले से ही स्पष्ट है कि मेट्रिसेस समान नहीं होंगे।

if not (Matrix.isEquallySized matrix1 matrix2) then false

इसके अलावा, मूल मैट्रिक्स मैट्रिक्स 1 और मैट्रिक्स 2 के आधार पर , हम सही या गलत से भरे एक नए मैट्रिक्स का निर्माण करते हैं , जो इस बात पर निर्भर करता है कि दोनों मैट्रिस की संबंधित कोशिकाएं मेल खाती हैं या नहीं।

matrix1.values
|> Array2D.mapi (fun x y v -> if matrix2.values.[x, y] <> v then false else true

Array2D.mapi फ़ंक्शन मैट्रिक्स 1 के सभी तत्वों पर निर्भर करता है और तीन पैरामीटर
x को हैंडलर - पंक्ति इंडेक्स
y - कॉलम इंडेक्स
v - सेल
सामग्री से गुजारता है। हम सेल v की सामग्री की तुलना संबंधित सेल मैट्रिक्स 2 से करते हैं और यदि वे समान हैं, तो सही लिखें , अन्यथा गलत लिखें ।

यदि झूठे तत्व के साथ कम से कम एक सेल है , तो इसका मतलब है कि मैट्रिस एक दूसरे के बराबर नहीं हैं।

चूंकि Array2D में फ़िल्टरिंग या खोज के तरीके नहीं हैं, इसलिए हम इसे स्वयं लागू करेंगे। ऐसा करने के लिए, हम मैट्रिक्स को रैखिक सूची में विघटित करते हैं

|> Seq.cast<bool>

और कम से कम एक बेमेल खोजें

|> Seq.contains false

Seq.contains फ़ंक्शन विस्तृत सूची में कम से कम एक गलत मान पाए जाने पर फ़ंक्शन सही लौटाएगा । इसलिए, हमें परिणाम को उलटने की आवश्यकता है ताकि == ऑपरेटर हमारे इच्छित तरीके से काम करे

else
    not (matrix1.values
           |> Array2D.mapi (fun x y v -> if matrix2.values.[x, y] <> v then false else true)
           |> Seq.cast<bool>
           |> Seq.contains false)

एक मैट्रिक्स ओ को शून्य या शून्य मैट्रिक्स कहा जाता है यदि इसके सभी तत्व शून्य के बराबर हैं।

static member O rows cols =
    let array2d = Array2D.zeroCreate rows cols
    { values = array2d }

इस फ़ंक्शन का उपयोग करने का एक उदाहरण

let AO = Matrix.O 5 5

मेरा मानना है कि कुछ भी जटिल नहीं है जिसे स्पष्टीकरण की आवश्यकता है, इसलिए हम जारी रखते हैं।

एक मैट्रिक्स जिसकी पंक्तियों की संख्या स्तंभों की संख्या के बराबर और n के बराबर होती है उसे ऑर्डर n का एक वर्ग मैट्रिक्स कहा जाता है

इस प्रकार, चौकोर मैट्रिक्स का रूप है।

A = [\begin{matrix} a 11 & a 12 & . . . & a 1 n \\ a 21 & a 22 & . . . & a 2 n \\ . . . & . . . & . . . & . . . \\ a n 1 & a n 2 & . . . & a n n \end{matrix}]

$A=\begin{bmatrix}a11&a12&...&a1n\\a21&a22&...&a2n\\...&...&...&...\\an1&an2&...&ann\end{bmatrix}$

इस नियम के भाग के रूप में, हम एक ऐसा फंक्शन बनाएंगे जो आयताकार मैट्रिक्स को वर्ग में न आने वाले सभी तत्वों को काटकर एक वर्ग मैट्रिक्स में बदल देता है।

static member toSquare matrix =

    //    
    let dim = Matrix.sizes matrix

    //   
    let colCount: int = snd dim
    //   
    let rowCount: int = fst dim

    //    
    let length = System.Math.Min (colCount, rowCount)

    //      
    //     
    let zero = Array2D.zeroCreate length length

    //     
    let square = zero |> Array2D.mapi (fun x y _ -> matrix.values.[x, y])

    //   
    { values = square }

स्रोत कोड में टिप्पणियां बताती हैं कि फ़ंक्शन कैसे काम करता है, तो चलो जारी रखें।

एक वर्ग मैट्रिक्स को त्रिकोणीय कहा जाता है यदि मुख्य विकर्ण के नीचे इसके सभी तत्व शून्य के बराबर हैं, अर्थात। त्रिकोणीय मैट्रिक्स का रूप है

T = (\begin{matrix} a 11 & a 12 & . . . & a 1 n \\ 0 & a 22 & . . . & a 2 n \\ . . . & . . . & . . . & . . . \\ 0 & 0 & . . . & a n n \end{matrix})

$T=\begin{pmatrix}a11&a12&...&a1n\\0&a22&...&a2n\\...&...&...&...\\0&0&...&ann\end{pmatrix}$

नीचे फ़ंक्शन कोड है जो मूल मैट्रिक्स को त्रिकोणीय एक में परिवर्तित करता है। लेकिन हमारे फ़ंक्शन में हम एक आयताकार मैट्रिक्स के साथ काम करेंगे, अर्थात यह वर्ग नहीं हो सकता है। पाठक आसानी से फ़ंक्शन कोड को संशोधित कर सकता है ताकि वह उस फ़ंक्शन का उपयोग करके एक वर्ग त्रिकोणीय मैट्रिक्स लौटाए जो हमने पहले जांच की थी।

static member T matrix =
    let values = matrix.values |> Array2D.mapi (fun x y v -> if y < x then 0 else v)
    { values = values }

Array2D.mapi फ़ंक्शन मूल दो-आयामी सरणी को एक हैंडलर का उपयोग करके एक नए में परिवर्तित करता है जो तीन पैरामीटर

x - पंक्ति संख्या
y - स्तंभ संख्या
v - सेल सामग्री लेता है

if y < x then 0 else v

यहां हम जांचते हैं कि क्या तत्व मुख्य विकर्ण के नीचे है और यदि ऐसा है, तो सेल 0. भरें, अन्यथा इनपुट मैट्रिक्स से प्रारंभिक मूल्य।

निम्नलिखित इस फ़ंक्शन का उपयोग करने का एक उदाहरण है।

let a = array2D [[1;2;3]
                 [4;5;6]
                 [7;8;9]
                 [10;11;12]]
let A = Matrix.ofArray2D a
let R = Matrix.triangular A
printfn "origin = \n %A" A.values
printfn "triangular = \n %A" R.values

हमें निम्न परिणाम मिलते हैं

origin = 
 [[1; 2; 3]
 [4; 5; 6]
 [7; 8; 9]
 [10; 11; 12]]
triangular = 
 [[1; 2; 3]
 [0; 5; 6]
 [0; 0; 9]
 [0; 0; 0]]

एक वर्ग मैट्रिक्स को विकर्ण कहा जाता है यदि मुख्य विकर्ण के बाहर स्थित इसके सभी तत्व शून्य के बराबर हैं

static member D matrix =
    let diagonal = matrix.values |> Array2D.mapi (fun x y v -> if x <> y then 0 else v)
    { values = diagonal }

यह फ़ंक्शन पिछले एक के समान है, केवल सत्यापन की स्थिति अलग है। नीचे उपयोग का एक उदाहरण है

let a = array2D [[1;2;3]
                 [4;5;6]
                 [7;8;9]
                 [10;11;12]]
let A = Matrix.ofArray2D a
let R = Matrix.D A
printfn "origin = \n %A" A.values
printfn "diagonal = \n %A" R.values

origin = 
 [[1; 2; 3]
 [4; 5; 6]
 [7; 8; 9]
 [10; 11; 12]]
diagonal = 
 [[1; 0; 0]
 [0; 5; 0]
 [0; 0; 9]
 [0; 0; 0]]

विकर्ण मैट्रिक्स इकाई है और ई द्वारा निरूपित किया जाता है यदि मुख्य विकर्ण पर स्थित इसके सभी तत्व एकता के बराबर हैं

E = (\begin{matrix} 1 & 0 & . . . & 0 \\ 0 & 1 & . . . & 0 \\ . . . & . . . & . . . & . . . \\ 0 & 0 & . . . & 1 \end{matrix})

$E=\begin{pmatrix}1&0&...&0\\0&1&...&0\\...&...&...&...\\0&0&...&1\end{pmatrix}$

एफ # पर इस तरह के मैट्रिक्स का कार्यान्वयन इस तरह दिखता है

static member E rows cols =
    let array2d = Array2D.init rows cols (fun x y -> if x = y then 1 else 0)
    { values = array2d }

मैट्रिक्स ऑपरेशन F # के साथ

कई कार्यों को मैट्रिस पर और साथ ही संख्याओं पर किया जा सकता है, जिनमें से कुछ संख्याओं पर संचालन के समान हैं, और कुछ विशिष्ट हैं।

दो आकृतियाँ Amn = (aij) और Bmn = (bij) का योग समान आकार A + B = Cmn = (cij) का मैट्रिक्स होता है , जिनके तत्व मैट्रिसेस A और B के तत्वों के योग के बराबर स्थानों पर स्थित होते हैं।

c i j = a i j + b i j, i = 1, 2, . . ., m, j = 1, 2, . . ., n

$cij=aij+bij, i=1,2,...,m, j=1,2,...,n$

उदाहरण, दिए गए मैट्रिक्स ए और बी के लिए, हम ए + बी का योग पाते हैं

A = (\begin{matrix} 2 & 3 \\ 1 & - 5 \\ 0 & 6 \end{matrix}), B = (\begin{matrix} - 3 & 3 \\ 1 & 7 \\ 2 & 0 \end{matrix}), A + B = (\begin{matrix} - 1 & 6 \\ 2 & 2 \\ 2 & 6 \end{matrix})

$A=\begin{pmatrix}2&3\\1&-5\\0&6\end{pmatrix}, B=\begin{pmatrix}-3&3\\1&7\\2&0\end{pmatrix}, A+B=\begin{pmatrix}-1&6\\2&2\\2&6\end{pmatrix}$

दो मैट्रिक्स जोड़ने के लिए कोड पर विचार करें

static member (+) (matrix1, matrix2) =
    if Matrix.isEquallySized matrix1 matrix2 then
        let array2d = matrix1.values |> Array2D.mapi (fun x y v -> matrix2.values.[x, y] + v)
        { values = array2d }
    else failwith "matrix1 is not equal to matrix2"

मैट्रिसेस जोड़ने से पहले, आपको यह सुनिश्चित करने की ज़रूरत है कि उनका आयाम मेल खाता है, अन्यथा फ़ंक्शन अपवाद फेंकता है। नीचे इस फ़ंक्शन का उपयोग करने का एक उदाहरण है

let a = array2D [[2;3]
                 [1;-5]
                 [0;6]]
let A = Matrix.ofArray2D a

let b = array2D [[-3;3]
                 [1;7]
                 [2;0]]
let B = Matrix.ofArray2D b

let R = A+B
printfn "A+B =\n %A" R.values

A+B =
 [[-1; 6]
 [2; 2]
 [2; 6]]

मैट्रिक्स के उत्पाद एक = (aij) संख्या से कश्मीर मैट्रिक्स है की के.ए. = (kaij) मैट्रिक्स के रूप में एक ही आकार के एक मैट्रिक्स के सभी तत्वों को गुणा करके प्राप्त एक संख्या से कश्मीर

उदाहरण के लिए, दिए गए मैट्रिक्स ए के लिए हम मैट्रिक्स 3 ए पाते हैं

A = (\begin{matrix} 2 & 3 & 0 \\ 1 & 5 & 4 \end{matrix}), 3 A = (\begin{matrix} 6 & 9 & 0 \\ 3 & 15 & 12 \end{matrix})

$A=\begin{pmatrix}2&3&0\\1&5&4\end{pmatrix}, 3A=\begin{pmatrix}6&9&0\\3&15&12\end{pmatrix}$

static member (*) (value, matrix) = 
    let array2d = matrix.values |> Array2D.mapi (fun _ _ v -> v * value)
    { values = array2d }

मैट्रिक्स ए = = (- 1) * ए को विपरीत मैट्रिक्स ए कहा जाएगा । इस परिभाषा से, हम आगे की ओर आसानी से आगे बढ़ते हैं

मैट्रिक्स का अंतर एक और बी बराबर आकार मैट्रिक्स का योग है एक और करने के लिए मैट्रिक्स विपरीत बी

static member (-) (matrix1: Matrix, matrix2: Matrix) = 
    if Matrix.isEquallySized matrix1 matrix2 then
        matrix1 + (-1)*matrix2
    else failwith "matrix1 is not equal to matrix2"

यदि पहले के स्तंभों की संख्या दूसरी पंक्तियों की संख्या के बराबर हो, तो दो मैट्रिक्स को संगत कहा जाता है

A = (\begin{matrix} 2 & 1 \\ 0 & 3 \end{matrix}), B = (\begin{matrix} 0 & 5 & 2 & 1 \\ 1 & 4 & 3 & 7 \end{matrix})

$A=\begin{pmatrix}2&1\\0&3\end{pmatrix}, B=\begin{pmatrix}0&5&2&1\\1&4&3&7\end{pmatrix}$

static member isMatched matrix1 matrix2 = 
    let row1Count = matrix1.values.[0,*].Length
    let col2Count = matrix2.values.[*,0].Length

    row1Count = col2Count

उन्हें गुणा करने के लिए मैट्रिक्स स्थिरता जाँच आवश्यक है।

उत्पाद AB सुसंगत मैट्रिक्स Amn = (aij) और Bnp = (bjk) मैट्रिक्स Cmn = (cik) है , तत्व cik की गणना मैट्रिक्स A के तत्वों i -th पंक्ति और मैट्रिक्स B के k वें स्तंभ के संगत तत्वों के योग के रूप में की जाती है।

मेट्रिसेस के उत्पाद की गणना करें

A = (\begin{matrix} 1 & 0 & 2 \\ 3 & 1 & 0 \end{matrix}), B = (\begin{matrix} - 1 & 0 \\ 5 & 1 \\ - 2 & 0 \end{matrix})

$A=\begin{pmatrix}1&0&2\\3&1&0\end{pmatrix}, B=\begin{pmatrix}-1&0\\5&1\\-2&0\end{pmatrix}$

मेट्रिसेस के उत्पाद का निर्धारण करने का निर्णय

A B = (\begin{matrix} 1 (- 1) + 0 * 5 + 2 (- 2) & 1 * 0 + 0 * 1 + 2 * 0 \\ 3 (- 1) + 1 * 5 + 0 (- 2) & 3 * 0 + 1 * 1 + 0 * 0 \end{matrix}) = (\begin{matrix} - 5 & 0 \\ 2 & 1 \end{matrix})

$AB=\begin{pmatrix}1(-1)+0*5+2(-2)&1*0+0*1+2*0\\3(-1)+1*5+0(-2)&3*0+1*1+0*0\end{pmatrix}= \begin{pmatrix}-5&0\\2&1\end{pmatrix}$

दो मैट्रिसेस को गुणा करने के लिए कोड पर विचार करें

static member (*) (matrix1, (matrix2: Matrix)) =
    if Matrix.isMatched matrix1 matrix2 then
        let row1Count = matrix1.values.[*,0].Length
        let col2Count = matrix2.values.[0,*].Length

        let values = Array2D.zeroCreate row1Count col2Count

        for r in 0..row1Count-1 do
            for c in 0..col2Count-1 do
                let row = Array.toList matrix1.values.[r,*]
                let col = Array.toList matrix2.values.[*,c]

                let cell = List.fold2 (fun acc val1 val2 -> acc + (val1 * val2)) 0 row col
                values.[r,c] <- cell

        { values = values }

    else failwith "matrix1 is not matched to matrix2"

आइए कोड को अधिक विस्तार से देखें।
गुणा करने से पहले, आपको यह सुनिश्चित करने की आवश्यकता है कि मैट्रिसेस सुसंगत हैं

if Matrix.isMatched matrix1 matrix2 then

परिणामी मैट्रिक्स में एक आयाम होगा जिसमें पंक्तियों की संख्या पहले मैट्रिक्स के समान है और कॉलम की संख्या दूसरी मैट्रिक्स के समान है

let row1Count = matrix1.values.[*,0].Length
let col2Count = matrix2.values.[0,*].Length

//        
let values = Array2D.zeroCreate row1Count col2Count

उसके बाद, हम सभी पंक्तियों और मूल मैट्रिक्स के सभी स्तंभों के माध्यम से लूप करते हैं

for r in 0..row1Count-1 do
    for c in 0..col2Count-1 do
        let row = Array.toList matrix1.values.[r,*]
        let col = Array.toList matrix2.values.[*,c]

हम प्रत्येक सेल के कुल मूल्य की गणना करते हैं

let cell = List.fold2 (fun acc val1 val2 -> acc + (val1 * val2)) 0 row col

List.fold2 फ़ंक्शन इनपुट (पंक्ति और स्तंभ) पर दो सूचियों को प्राप्त करता है और निम्न पैरामीटर को हैंडलर

एसीसी में पास करता है - संचयकर्ता जिसमें पिछली गणना
वैल 1 का परिणाम होता है - पहली सरणी से सेल की सामग्री। हमारे मामले में, यह पहली मैट्रिक्स
वेल 2 से पंक्ति है - दूसरे सरणी से सेल की सामग्री, अर्थात् , दूसरे मैट्रिक्स के कॉलम।

चूंकि मैट्रिसेस सुसंगत हैं, हमें यकीन है कि हम सरणियों से आगे नहीं जाएंगे।

हैंडलर संचयकर्ता को पंक्तियों और एक स्तंभ से कोशिकाओं का एक उत्पाद जोड़ता है, और परिणामस्वरूप मूल्य अगले पुनरावृत्ति को पारित किया जाएगा। इस प्रकार, List.fold2 फ़ंक्शन का अंतिम परिणामदो मैट्रिक्स के उत्पादों का अंतिम मूल्य होगा। यह केवल पहले से बनाई गई खाली मैट्रिक्स के साथ उन्हें भरने के लिए बनी हुई है

values.[r,c] <- cell

जिसके परिणाम स्वरूप वापसी होगी

{ values = values }

नीचे इस फ़ंक्शन का उपयोग करने का एक उदाहरण है

let a = array2D [[1;0;2]
                 [3;1;0]]
let A = Matrix.ofArray2D a

let b = array2D [[-1;0]
                 [5;1]
                 [-2;0]]
let B = Matrix.ofArray2D b

let R = A*B

printfn "A*B =\n %A" R.values

A1*B1 =
 [[-5; 0]
 [2; 1]]

यदि k square N, तो एक वर्ग मैट्रिक्स A की kth शक्ति k matrices A का उत्पाद है

A^{k} = A * A * . . . A (k - р а з)

$A^k=A*A*...A (k- )$

मैट्रिक्स के उत्पाद के लिए F # पर कोड पर विचार करें। टेल रिकर्सियन का उपयोग यहां बड़ी शक्तियों के साथ स्टैक को ओवरफ्लो करने के लिए नहीं किया जाएगा। पूंछ पुनरावृत्ति एक पुनरावृत्ति है जो संकलक अंततः एक लूप में परिवर्तित हो जाती है। यदि संभव हो तो, यह अनुशंसा की जाती है कि आप हमेशा सामान्य एक के बजाय पूंछ पुनरावृत्ति का उपयोग करें, लेकिन इसके लिए आपको अंतिम गणना मूल्य वापस करने के लिए प्रत्येक पुनरावर्तन फ्रेम की आवश्यकता होती है। इस मान को आमतौर पर संचायक कहा जाता है और अगले पुनरावर्तन फ़्रेम में पास किया जाता है। अर्थात्, नियमित पुनरावर्तन के विपरीत, जो स्टैक के ऊपर परिकलित मान लौटाता है, पूंछ पुनरावृत्ति स्टैक के नीचे परिकलित मान से गुजरती है। प्रत्येक नए पुनरावर्तन फ़्रेम अपनी गणना स्वयं करता है और उन्हें पहले परिकलित मान में जोड़ता है, जिसे बैटरी में संग्रहीत किया जाता है। उसके बाद,जैसा कि पुनरावृत्ति के अंतिम फ्रेम ने काम किया, संचयकर्ता के पास पहले से ही एक गणना मूल्य है, जो केवल परिणाम के रूप में लौटता है।

इस प्रकार, संकलक कोड को अनुकूलित कर सकता है और इसे एक नियमित लूप में बदल सकता है।


//    
// matrix -  
// value -  
static member (^^) (matrix, value) =

    //  ,    
    // m - 
    // p =  
    let inRecPow m p =

        //  
        // acc -  .   Matrix
        // p -     
        //         
        let rec recPow acc p =
            //   
            match p with
            | x when x > 0 ->
                //    
                //      ,      
                let nextAcc = acc*m
                //           
                recPow nextAcc (x-1)
            //    ,    
            | _ -> acc

        //   ,         
        let dim = Matrix.sizes matrix
        let colCount = snd dim
        let rowCount = fst dim

        let u = Matrix.E rowCount colCount
        //           
        recPow u p

    //  ,      
    let powMatrix = inRecPow matrix value
    //   
    { values = powMatrix.values }

कोड में विस्तृत टिप्पणी है कि यह कैसे काम करता है। थोड़ा स्पष्टीकरण की आवश्यकता है, यूनिट मैट्रिक्स का उपयोग क्यों किया जाता है? यह पुनरावृत्ति के पहले फ्रेम के लिए आवश्यक है और संचायक के आधार मूल्य के रूप में कार्य करता है, जिसमें अंतिम परिणाम जमा होगा।
नीचे हमारे फ़ंक्शन का उपयोग करने का एक उदाहरण है

A = (\begin{matrix} 1 & 0 \\ 2 & - 1 \end{matrix})

$A=\begin{pmatrix}1&0\\2&-1\end{pmatrix}$

A^{2} = A A = (\begin{matrix} 1 & 0 \\ 2 & - 1 \end{matrix}) (\begin{matrix} 1 & 0 \\ 2 & - 1 \end{matrix}) = (\begin{matrix} 1 & 0 \\ 0 & 1 \end{matrix})

$A^2=AA=\begin{pmatrix}1&0\\2&-1\end{pmatrix}\begin{pmatrix}1&0\\2&-1\end{pmatrix}=\begin{pmatrix}1&0\\0&1\end{pmatrix}$

A^{3} = A A^{2} = (\begin{matrix} 1 & 0 \\ 2 & - 1 \end{matrix}) (\begin{matrix} 1 & 0 \\ 0 & 1 \end{matrix}) = (\begin{matrix} 1 & 0 \\ 2 & - 1 \end{matrix})

$A^3=AA^2=\begin{pmatrix}1&0\\2&-1\end{pmatrix}\begin{pmatrix}1&0\\0&1\end{pmatrix}=\begin{pmatrix}1&0\\2&-1\end{pmatrix}$

हम निम्नलिखित उत्पाद की गणना करते हैं

f (A) = 2 A^{3} - 4 A^{2} + 3 E

$f(A)=2A^3-4A^2+3E$

जहां E पहचान मैट्रिक्स है। चूंकि हम मैट्रिक्स में कोई संख्या नहीं जोड़ सकते हैं, इसलिए हमें 3E जोड़ना होगा ।

2 (\begin{matrix} 1 & 0 \\ 2 & - 1 \end{matrix}) - 4 (\begin{matrix} 1 & 0 \\ 0 & 1 \end{matrix}) + 3 (\begin{matrix} 1 & 0 \\ 0 & 1 \end{matrix}) = (\begin{matrix} 1 & 0 \\ 4 & - 3 \end{matrix})

$2\begin{pmatrix}1&0\\2&-1\end{pmatrix}- 4\begin{pmatrix}1&0\\0&1\end{pmatrix}+ 3\begin{pmatrix}1&0\\0&1\end{pmatrix}= \begin{pmatrix}1&0\\4&-3\end{pmatrix}$

//     
static member (+) (matrix, (value: int)) =
    let dim = Matrix.sizes matrix
    let r = fst dim
    let c = snd dim

    //   
    let unit = Matrix.E r c
    //          
    value*unit + matrix

let a = array2D [[1;0]
                 [2;-1]]
let A = Matrix.ofArray2D a

let R = 2*(A^^3) - 4*(A^^2) + 3
printfn "2*A^3 - 4*A^2 + 3 =\n %A" R.values

2*A5^3 - 4*A5^2 + 3 =
 [[1; 0]
 [4; -3]]

एक मैट्रिक्स A ^T जिसके कॉलम समान संख्याओं के साथ मैट्रिक्स A की पंक्तियों से बने होते हैं और तत्वों के समान अनुक्रम को मैट्रिक्स A में स्थानांतरित किया जाता है

static member transpose matrix =
    let dim = Matrix.sizes matrix
    let rows = fst dim
    let cols = snd dim

    //      
    let tMatrix = Matrix.O cols rows
    //       
    matrix.values |> Array2D.iteri(fun x y v -> tMatrix.values.[y, x] <- v)

    //  
    tMatrix

उदाहरण का उपयोग करें

let a = array2D [[1;2;3]
                 [4;5;6]
                 [7;8;9]
                 [10;11;12]]
let A = Matrix.ofArray2D a
let R6 = Matrix.T A
printfn "origin = \n %A" A.values
printfn "transpose = \n %A" R.values

origin = 
 [[1; 2; 3]
 [4; 5; 6]
 [7; 8; 9]
 [10; 11; 12]]
transpose = 
 [[1; 4; 7; 10]
 [2; 5; 8; 11]
 [3; 6; 9; 12]]

सारांश

इस लेख में, हमने रैखिक बीजगणित के सिद्धांत से मैट्रिक्स के कार्यान्वयन और उपयोग के उदाहरणों की जांच की। साथ ही उन पर बुनियादी गणितीय संचालन, एफ # में एक कार्यात्मक दृष्टिकोण का उपयोग कर। मुझे उम्मीद है कि पाठक लचीलेपन की सराहना कर सकते हैं जो कार्यात्मक भाषा प्रदान करते हैं।

मैट्रिक्स मॉड्यूल का पूर्ण स्रोत कोड, जिसके टुकड़े को लेख के ढांचे में माना गया था, आप गिटब पर पा सकते हैं।

गिथब मैट्रिक्स। एफएएस

रैखिक बीजगणित के सिद्धांत से मैट्रिस के साथ काम करने के एक उदाहरण के रूप में कार्यात्मक प्रोग्रामिंग

परिचय

मैट्रिक्स की परिभाषा और एफ # में कार्यान्वयन

मैट्रिक्स ऑपरेशन F # के साथ

सारांश

More articles: