NdArray

इस सरणी की सामग्री को गंतव्य सरणी में कॉपी करें।

गंतव्य सरणी का shape() इस सरणी के आकार के बराबर होना चाहिए, या एक अपवाद फेंक दिया जाएगा। प्रतिलिपि के बाद, दोनों सरणियों की सामग्री को एक-दूसरे को प्रभावित किए बिना, स्वतंत्र रूप से बदला जा सकता है।

किसी दिए गए आयाम पर सभी तत्वों का अनुक्रम लौटाता है।

तार्किक रूप से, एन-आयामी सरणी को एक ही वेक्टर में समतल किया जा सकता है, जहां कुल size() मानों के लिए (n - 1) वें तत्व के स्केलर (n) वें तत्व से पहले होते हैं।

उदाहरण के लिए, [x, y] अक्षों पर एक nxm मैट्रिक्स दिए जाने पर, तत्वों को निम्नलिखित क्रम में पुनरावृत्त किया जाता है:

x ₀ y ₀ , x ₀ y ₁ , ..., x ₀ y _m-1 , x ₁ y ₀ , x ₁ y ₁ , ..., x _n-1 y _m-1

लौटाए गए अनुक्रम को forEach(Consumer) या forEachIndexed(BiConsumer) पर कॉल करके प्रत्येक तत्व पर जाने के लिए पुनरावृत्त किया जा सकता है।

// Iterate matrix for initializing each of its vectors
    matrixOfFloats.elements(0).forEach(v -> {
      v.set(vector(1.0f, 2.0f, 3.0f));
    );

    // Iterate a vector for reading each of its scalar
    vectorOfFloats.scalars().forEachIdx((coords, s) -> {
      System.out.println("Value " + s.getFloat() + " found at " + coords);
    });
 }

एन-आयामी सरणियों के बीच समानता की जाँच करता है।

एक सरणी किसी अन्य ऑब्जेक्ट के बराबर होती है यदि यह ऑब्जेक्ट समान आकार, प्रकार का एक और NdArray है और तत्व समान और समान क्रम में हैं। उदाहरण के लिए:

IntNdArray array = NdArrays.ofInts(Shape.of(2, 2))
    .set(NdArrays.vectorOf(1, 2), 0)
    .set(NdArrays.vectorOf(3, 4), 1);

 assertEquals(array, StdArrays.ndCopyOf(new int[][] { {1, 2, {3, 4} }));  // true
 assertEquals(array, StdArrays.ndCopyOf(new Integer[][] { {1, 2}, {3, 4} }));  // true, as Integers are equal to ints
 assertNotEquals(array, NdArrays.vectorOf(1, 2, 3, 4));  // false, different shapes
 assertNotEquals(array, StdArrays.ndCopyOf(new int[][] { {3, 4}, {1, 2} }));  // false, different order
 assertNotEquals(array, StdArrays.ndCopyOf(new long[][] { {1L, 2L}, {3L, 4L} }));  // false, different types
 }

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

दिए गए निर्देशांक पर इस सरणी का एन-आयामी तत्व लौटाता है।

इस सरणी के किसी भी आयाम के तत्वों को पुनः प्राप्त किया जा सकता है। उदाहरण के लिए, यदि निर्देशांक की संख्या इस सरणी के आयामों की संख्या के बराबर है, तो एक रैंक-0 (स्केलर) सरणी लौटा दी जाती है, जिसका मान `array.getObject()` पर कॉल करके प्राप्त किया जा सकता है।

लौटाए गए तत्वों पर लागू कोई भी परिवर्तन इस सरणी के डेटा को भी प्रभावित करता है, क्योंकि इसमें कोई प्रतिलिपि शामिल नहीं है।

ध्यान दें कि इस विधि को लागू करना इस सरणी को एकल स्केलर पर स्लाइस करने का एक समतुल्य और अधिक कुशल तरीका है, यानी array.get(x, y, z) array.slice(at(x), at(y), at(z)) के बराबर है array.slice(at(x), at(y), at(z))

दिए गए निर्देशांक पर पाए गए अदिश मान को लौटाता है।

स्केलर तत्व तक पहुंचने के लिए, प्रदान किए गए निर्देशांक की संख्या इस सरणी के आयामों की संख्या (यानी इसकी रैंक) के बराबर होनी चाहिए। उदाहरण के लिए:

FloatNdArray matrix = NdArrays.ofFloats(shape(2, 2));  // matrix rank = 2
  matrix.getObject(0, 1);  // succeeds, returns 0.0f
  matrix.getObject(0);  // throws IllegalRankException

  FloatNdArray scalar = matrix.get(0, 1);  // scalar rank = 0
  scalar.getObject();  // succeeds, returns 0.0f
 

इस एन-आयामी सरणी की सामग्री को गंतव्य बफर में पढ़ें।

बफ़र का आकार इस सरणी के size() के बराबर या उससे अधिक होना चाहिए, अन्यथा एक अपवाद फेंक दिया जाएगा। प्रतिलिपि के बाद, बफ़र और सरणी की सामग्री को एक-दूसरे को प्रभावित किए बिना, स्वतंत्र रूप से बदला जा सकता है।

इस सरणी में सभी अदिशों का अनुक्रम लौटाता है।

यह कॉल elements(shape().numDimensions() - 1) के बराबर है

दिए गए निर्देशांक पर पाए जाने वाले एन-आयामी तत्व का मान निर्दिष्ट करता है।

प्रदान किए गए निर्देशांकों की संख्या 0 और रैंक - 1 के बीच कहीं भी हो सकती है। उदाहरण के लिए:

FloatNdArray matrix = NdArrays.ofFloats(shape(2, 2));  // matrix rank = 2
  matrix.set(vector(10.0f, 20.0f), 0);  // success
  matrix.set(scalar(10.0f), 1, 0); // success
 

दिए गए निर्देशांकों पर पाए जाने वाले अदिश मान को निर्दिष्ट करता है।

स्केलर तत्व तक पहुंचने के लिए, प्रदान किए गए निर्देशांक की संख्या इस सरणी के आयामों की संख्या (यानी इसकी रैंक) के बराबर होनी चाहिए। उदाहरण के लिए:

FloatNdArray matrix = NdArrays.ofFloats(shape(2, 2));  // matrix rank = 2
  matrix.setObject(10.0f, 0, 1);  // succeeds
  matrix.setObject(10.0f, 0);  // throws IllegalRankException

  FloatNdArray scalar = matrix.get(0, 1);  // scalar rank = 0
  scalar.setObject(10.0f);  // succeeds
 

दिए गए सूचकांक चयनकर्ताओं के लिए एक या अधिक आयामों को मैप करके इस सरणी का एक बहु-आयामी दृश्य (या स्लाइस) बनाता है।

स्लाइस किसी एन-आयामी सरणी को उसके किसी भी अक्ष में पार करने और/या केवल रुचि के तत्वों को फ़िल्टर करने की अनुमति देते हैं। उदाहरण के लिए, [x, y] अक्षों पर दिए गए मैट्रिक्स के लिए, सभी x के लिए y=0 पर तत्वों को पुनरावृत्त करना संभव है।

लौटाए गए स्लाइस पर लागू कोई भी परिवर्तन इस सरणी के डेटा को भी प्रभावित करता है, क्योंकि इसमें कोई प्रतिलिपि शामिल नहीं है।

उपयोग का उदाहरण:

FloatNdArray matrix3d = NdArrays.ofFloats(shape(3, 2, 4));  // with [x, y, z] axes

    // Iterates elements on the x axis by preserving only the 3rd value on the z axis,
    // (i.e. [x, y, 2])
    matrix3d.slice(all(), all(), at(2)).elements(0).forEach(m -> {
      assertEquals(shape(2), m); // y=2, z=0 (scalar)
    );

    // Creates a slice that contains only the last element of the y axis and elements with an
    // odd `z` coordinate.
    FloatNdArray slice = matrix3d.slice(all(), at(1), odd());
    assertEquals(shape(3, 2), slice.shape());  // x=3, y=0 (scalar), z=2 (odd coordinates)

    // Iterates backward the elements on the x axis
    matrix3d.slice(flip()).elements(0).forEach(m -> {
      assertEquals(shape(2, 4), m);  // y=2, z=4
    });
 }

स्रोत बफ़र से इस एन-आयामी सरणी की सामग्री लिखें।

बफ़र का आकार इस सरणी के size() के बराबर या उससे अधिक होना चाहिए, अन्यथा एक अपवाद फेंक दिया जाएगा। प्रतिलिपि के बाद, बफ़र और सरणी की सामग्री को एक-दूसरे को प्रभावित किए बिना, स्वतंत्र रूप से बदला जा सकता है।