Fortran में Arrays: एक-आयामी और बहु-आयामी Arrays का परिचय

Arrays का उपयोग Fortran में एक ही प्रकार के डेटा के कई मानों को एक संगठित संरचना में स्टोर करने के लिए किया जाता है। यह अध्याय Fortran में Arrays की बुनियादी अवधारणाओं को समझाता है, जैसे कि एक-आयामी (1D) और बहु-आयामी (Multi-dimensional) Arrays का डिक्लेरेशन और उपयोग। आप सीखेंगे कि Arrays के साथ गणितीय ऑपरेशन्स कैसे किए जाते हैं और Fortran में इनकी उपयोगिता कैसे बढ़ाई जा सकती है। इस अध्याय के अंत तक, आप Arrays को कुशलता से उपयोग करने में सक्षम होंगे।

Arrays का परिचय

Fortran में Arrays एक महत्वपूर्ण डेटा संरचना हैं, जिनका उपयोग एक ही प्रकार के कई मानों (values) को संगठित तरीके से स्टोर करने के लिए किया जाता है। Arrays आपको डेटा के सेट्स को एक ही वेरिएबल नाम के तहत संग्रहित करने की सुविधा देते हैं, जिससे आप आसानी से उन पर गणितीय और तार्किक ऑपरेशन्स कर सकते हैं।

1. Arrays क्या हैं?

Arrays कई मानों का एक क्रमबद्ध समूह होता है, जो एक ही प्रकार के होते हैं। आप इसे एक प्रकार के कंटेनर के रूप में समझ सकते हैं, जिसमें संख्याएँ, वर्ण, या अन्य डेटा एक निश्चित क्रम में संग्रहीत होते हैं। Fortran में, Arrays एक या अधिक आयामों में बनाए जा सकते हैं:

• एक-आयामी Arrays (1D Arrays): यह एक सीधी लाइन में डेटा को संग्रहीत करते हैं, जैसे कि संख्याओं की एक सूची।
• बहु-आयामी Arrays (Multi-dimensional Arrays): यह एक ग्रिड या तालिका के रूप में डेटा संग्रहीत करते हैं, जैसे कि 2D या 3D ग्रिड।

2. Arrays को क्यों उपयोग करें?

Arrays का उपयोग तब किया जाता है जब आपको एक ही प्रकार के डेटा के एक बड़े सेट को प्रबंधित करने की आवश्यकता होती है। इसकी प्रमुख उपयोगिताएँ निम्नलिखित हैं:

• डेटा की कुशलता: Arrays के साथ आप सैकड़ों या हजारों मानों को एक ही वेरिएबल में संग्रहित कर सकते हैं और उन पर ऑपरेशन्स आसानी से कर सकते हैं।
• इंडेक्सिंग: Arrays को इंडेक्स (क्रमांक) के आधार पर एक्सेस किया जाता है, जिससे आप विशेष मानों को जल्दी और कुशलता से ढूंढ सकते हैं।
• गणितीय और तार्किक ऑपरेशन्स: Fortran में Arrays के साथ गणितीय और तार्किक ऑपरेशन्स को एक साथ किया जा सकता है, जो इसे वैज्ञानिक और तकनीकी गणनाओं के लिए अत्यधिक उपयोगी बनाता है।

3. एक साधारण Array का उदाहरण:

program array_example
    integer, dimension(5) :: numbers

    ! Array में मान असाइन करना
    numbers = (/ 10, 20, 30, 40, 50 /)

    ! Array के मान प्रिंट करना
    print *, "Array के मान हैं:", numbers
end program array_example

स्पष्टीकरण: इस उदाहरण में, हमने एक 1D Array numbers डिक्लेयर किया है, जिसमें पाँच पूर्णांक मान (10, 20, 30, 40, 50) संग्रहीत किए गए हैं। dimension(5) बताता है कि इस Array में पाँच तत्व होंगे।

4. बहु-आयामी Array का उदाहरण:

program multi_dimensional_array
    integer, dimension(3,3) :: matrix

    ! Matrix में मान असाइन करना
    matrix = reshape((/ 1, 2, 3, 4, 5, 6, 7, 8, 9 /), (/ 3, 3 /))

    ! Matrix के मान प्रिंट करना
    print *, "Matrix के मान हैं:"
    print *, matrix
end program multi_dimensional_array

स्पष्टीकरण: इस उदाहरण में, हमने एक 2D Array matrix डिक्लेयर किया है, जिसमें 3×3 ग्रिड के रूप में संख्याएँ संग्रहीत की गई हैं। reshape फ़ंक्शन का उपयोग करके हमने एक 1D Array को 2D Matrix में रूपांतरित किया है।

Multi-dimensional Arrays

Fortran में Multi-dimensional Arrays का उपयोग तब किया जाता है जब डेटा को एक से अधिक आयामों में संग्रहीत और प्रबंधित करने की आवश्यकता होती है। इन Arrays को तालिका (table), ग्रिड (grid), या मैट्रिक्स (matrix) के रूप में समझा जा सकता है, जहाँ प्रत्येक मान को उसके स्थान (इंडेक्स) के अनुसार एक्सेस किया जाता है। Multi-dimensional Arrays विशेष रूप से वैज्ञानिक और इंजीनियरिंग गणनाओं में उपयोगी होते हैं, जहाँ कई आयामों में डेटा की आवश्यकता होती है।

1. Multi-dimensional Arrays का परिचय:

Multi-dimensional Arrays एक से अधिक आयामों में डेटा को संग्रहीत करते हैं। जैसे:

• 2D Array (2-आयामी Array): यह एक तालिका (rows और columns) के रूप में डेटा को संग्रहीत करता है।
• 3D Array (3-आयामी Array): यह कई तालिकाओं (layers) का प्रतिनिधित्व करता है, जहाँ प्रत्येक तालिका 2D होती है।

Multi-dimensional Arrays को इंडेक्स के आधार पर एक्सेस किया जाता है, जहाँ हर आयाम में एक इंडेक्स होता है। उदाहरण के लिए, 2D Array में दो इंडेक्स होते हैं: एक row के लिए और एक column के लिए।

2. Multi-dimensional Array का डिक्लेरेशन:

Fortran में Multi-dimensional Arrays को dimension कीवर्ड के साथ डिक्लेयर किया जाता है। उदाहरण के लिए, एक 2D Array को इस प्रकार डिक्लेयर किया जाता है:

integer, dimension(3, 3) :: matrix

इस उदाहरण में:

• matrix एक 2D Array है जिसमें 3 rows और 3 columns हैं।
• Array में कुल 9 तत्व होते हैं (3×3)।

3. Multi-dimensional Array का उदाहरण:

program multi_dim_array_example
    integer, dimension(3, 3) :: matrix
    integer :: i, j

    ! Array में मान असाइन करना
    matrix = reshape((/ 1, 2, 3, 4, 5, 6, 7, 8, 9 /), (/ 3, 3 /))

    ! Array के मान प्रिंट करना
    print *, "Matrix के मान हैं:"
    do i = 1, 3
        do j = 1, 3
            print *, "matrix(", i, ",", j, ") =", matrix(i, j)
        end do
    end do
end program multi_dim_array_example

स्पष्टीकरण:

• इस उदाहरण में, हमने एक 3×3 मैट्रिक्स डिक्लेयर किया है।
• reshape फ़ंक्शन का उपयोग करके हमने एक 1D Array को 3×3 2D Array में रूपांतरित किया है।
• दो do loops का उपयोग करके हम Array के सभी मानों को प्रिंट कर रहे हैं। प्रत्येक matrix(i, j) इंडेक्स से जुड़ा एक मान प्रिंट होता है।

4. 3D Array का उदाहरण:

program three_d_array
    integer, dimension(2, 2, 2) :: cube
    integer :: i, j, k

    ! Array में मान असाइन करना
    cube = reshape((/ 1, 2, 3, 4, 5, 6, 7, 8 /), (/ 2, 2, 2 /))

    ! Array के मान प्रिंट करना
    print *, "3D Array के मान:"
    do i = 1, 2
        do j = 1, 2
            do k = 1, 2
                print *, "cube(", i, ",", j, ",", k, ") =", cube(i, j, k)
            end do
        end do
    end do
end program three_d_array

स्पष्टीकरण:

• इस उदाहरण में, हमने एक 3D Array cube डिक्लेयर किया है, जिसका आकार 2x2x2 है।
• reshape का उपयोग करके हमने 8 मानों वाले एक 1D Array को 3D Array में बदला।
• तीन nested loops का उपयोग करके हम सभी मानों को प्रिंट कर रहे हैं, जहाँ cube(i, j, k) के प्रत्येक इंडेक्स से एक मान एक्सेस किया जाता है।

5. Multi-dimensional Arrays के लाभ:

• डेटा का बेहतर संगठन: Multi-dimensional Arrays आपको डेटा को अधिक व्यवस्थित और स्पष्ट रूप से प्रबंधित करने में मदद करते हैं, खासकर तब जब डेटा कई आयामों में हो।
• गणितीय गणनाएँ: 2D और 3D Arrays का उपयोग वैज्ञानिक गणनाओं, मैट्रिक्स ऑपरेशन्स, और ग्रिड आधारित सिमुलेशन के लिए किया जाता है।
• डेटा एक्सेस और मैनीप्युलेशन: Multi-dimensional Arrays का उपयोग करके आप डेटा के सेट्स को अधिक कुशलता से एक्सेस और मॉडिफाई कर सकते हैं।

Array Operations

Fortran में Array Operations आपको Arrays के साथ सीधे गणितीय और तार्किक ऑपरेशन्स करने की सुविधा प्रदान करते हैं। ये ऑपरेशन्स बहुत ही कुशल होते हैं और एक साथ पूरे Array या उसके कुछ हिस्सों पर लागू किए जा सकते हैं। Array Operations के साथ आप आसानी से जोड़, घटाव, गुणा, विभाजन, और अन्य गणितीय कार्य कर सकते हैं।

1. Array पर गणितीय ऑपरेशन्स:

Fortran में आप पूरी Array पर या उसकी उप-Arrays (sub-arrays) पर सीधे गणितीय ऑपरेशन्स कर सकते हैं। इन ऑपरेशन्स को हर Array के तत्व पर एक साथ लागू किया जाता है।

उदाहरण: जोड़ (Addition)

program array_addition
    integer, dimension(3) :: a = (/ 1, 2, 3 /)
    integer, dimension(3) :: b = (/ 4, 5, 6 /)
    integer, dimension(3) :: result

    result = a + b  ! Array जोड़

    print *, "Array जोड़ का परिणाम:", result
end program array_addition

स्पष्टीकरण: यहाँ पर a + b हर तत्व को जोड़ता है:

• 1 + 4 = 5
• 2 + 5 = 7
• 3 + 6 = 9

आउटपुट: Array जोड़ का परिणाम: 5 7 9

उदाहरण: घटाव (Subtraction)

program array_subtraction
    integer, dimension(3) :: a = (/ 10, 20, 30 /)
    integer, dimension(3) :: b = (/ 4, 5, 6 /)
    integer, dimension(3) :: result

    result = a - b  ! Array घटाव

    print *, "Array घटाव का परिणाम:", result
end program array_subtraction

आउटपुट: Array घटाव का परिणाम: 6 15 24

2. Array पर गुणा और विभाजन (Multiplication and Division):

आप Array के प्रत्येक तत्व पर गुणा और विभाजन के ऑपरेशन्स भी कर सकते हैं।

उदाहरण: गुणा (Multiplication)

program array_multiplication
    integer, dimension(3) :: a = (/ 2, 4, 6 /)
    integer, dimension(3) :: b = (/ 3, 5, 7 /)
    integer, dimension(3) :: result

    result = a * b  ! Array गुणा

    print *, "Array गुणा का परिणाम:", result
end program array_multiplication

आउटपुट: Array गुणा का परिणाम: 6 20 42

उदाहरण: विभाजन (Division)

program array_division
    real, dimension(3) :: a = (/ 10.0, 20.0, 30.0 /)
    real, dimension(3) :: b = (/ 2.0, 5.0, 6.0 /)
    real, dimension(3) :: result

    result = a / b  ! Array विभाजन

    print *, "Array विभाजन का परिणाम:", result
end program array_division

आउटपुट: Array विभाजन का परिणाम: 5.0 4.0 5.0

3. Scalar और Array के बीच ऑपरेशन्स:

Fortran में आप किसी Array के सभी तत्वों पर एक scalar (एकल मान) के साथ भी ऑपरेशन्स कर सकते हैं। Scalar के साथ ऑपरेशन हर Array के तत्व पर समान रूप से लागू होता है।

उदाहरण: Array के प्रत्येक तत्व को Scalar से गुणा करना

program scalar_multiplication
    integer, dimension(3) :: a = (/ 1, 2, 3 /)
    integer :: scalar = 5
    integer, dimension(3) :: result

    result = a * scalar  ! Scalar से Array का गुणा

    print *, "Scalar गुणा का परिणाम:", result
end program scalar_multiplication

आउटपुट: Scalar गुणा का परिणाम: 5 10 15

4. Array Reduction Operations:

Fortran में कुछ विशेष फ़ंक्शंस होते हैं, जिनका उपयोग पूरे Array को एकल मान में “reduce” करने के लिए किया जाता है। ये ऑपरेशन्स विशेष रूप से गणितीय गणनाओं में उपयोगी होते हैं, जैसे कि Array के सभी तत्वों का योग या उत्पाद।

उदाहरण: Array का योग (SUM)

program array_sum
    integer, dimension(5) :: a = (/ 1, 2, 3, 4, 5 /)
    integer :: total

    total = sum(a)  ! Array का योग

    print *, "Array का योग:", total
end program array_sum

आउटपुट: Array का योग: 15

उदाहरण: Array का अधिकतम मान (MAXVAL)

program array_max
    integer, dimension(5) :: a = (/ 1, 5, 3, 9, 2 /)
    integer :: max_value

    max_value = maxval(a)  ! Array का अधिकतम मान

    print *, "Array का अधिकतम मान:", max_value
end program array_max

आउटपुट: Array का अधिकतम मान: 9

5. Array में तार्किक ऑपरेशन्स (Logical Operations):

आप Arrays में तार्किक ऑपरेशन्स भी कर सकते हैं, जैसे कि AND, OR, और NOT ऑपरेशन्स।

उदाहरण: Array में तार्किक ऑपरेशन्स

program array_logical
    logical, dimension(3) :: a = (/ .true., .false., .true. /)
    logical, dimension(3) :: b = (/ .false., .true., .true. /)
    logical, dimension(3) :: result

    result = a .and. b  ! AND ऑपरेशन

    print *, "Logical AND का परिणाम:", result
end program array_logical

आउटपुट: Logical AND का परिणाम: F F T