NdArray

העתק את התוכן של מערך זה למערך היעד.

shape() של מערך היעד חייבת להיות שווה לצורה של מערך זה, אחרת נזרק חריג. לאחר ההעתקה, ניתן לשנות את התוכן של שני המערכים באופן עצמאי, מבלי להשפיע זה על זה.

מחזירה רצף של כל האלמנטים בממד נתון.

באופן הגיוני, ניתן לשטח את המערך N-ממדי בוקטור יחיד, כאשר הסקלרים של האלמנט (n - 1) קודמים לאלו של האלמנט (n) ה-th, עבור סך ערכי size() .

לדוגמה, בהינתן מטריצת nxm על צירי [x, y] , אלמנטים חוזרים בסדר הבא:

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);
    });
 }

בודק שוויון בין מערכים n-ממדיים.

מערך שווה לאובייקט אחר אם אובייקט זה הוא 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
 }

שימו לב שהחישוב הנדרש לאימות שוויון בין שני מערכים יכול להיות יקר במקרים מסוימים ולכן, מומלץ לא להשתמש בשיטה זו בנתיב קריטי שבו יש חשיבות לביצועים.

מחזירה את האלמנט N-ממדי של מערך זה בקואורדינטות הנתונות.

ניתן לאחזר אלמנטים מכל אחד מהממדים של מערך זה. לדוגמה, אם מספר הקואורדינטות שווה למספר הממדים של מערך זה, מוחזר מערך rank-0 (סקלארי), אשר לאחר מכן ניתן לקבל את הערך על ידי קריאת `array.getObject()`.

כל שינוי שהוחל על הרכיבים המוחזרים משפיע גם על הנתונים של מערך זה, מכיוון שאין עותק מעורב.

שים לב שהפעלת שיטה זו היא דרך מקבילה ויעילה יותר לפרוס מערך זה על סקלר בודד, כלומר array.get(x, y, 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
 

קרא את התוכן של מערך N-ממדי זה לתוך מאגר היעד.

גודל המאגר חייב להיות שווה או גדול יותר size() של מערך זה, או שיוצא חריג. לאחר ההעתקה, ניתן לשנות את התוכן של המאגר והמערך באופן עצמאי, מבלי להשפיע זה על זה.

מחזירה רצף של כל הסקלרים במערך זה.

זה שווה ערך ל-call elements(shape().numDimensions() - 1)

מקצה את הערך של האלמנט N-ממדי שנמצא בקואורדינטות הנתונות.

מספר הקואורדינטות שסופק יכול להיות בכל מקום בין 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
 

יוצר תצוגה רב-ממדית (או פרוסה) של מערך זה על ידי מיפוי מימד אחד או יותר לבוררי האינדקס הנתונים.

פרוסות מאפשרות לחצות מערך N-ממדי בכל אחד מהצירים שלו ו/או לסנן רק אלמנטים בעלי עניין. לדוגמה, עבור מטריצה ​​נתונה בצירי [x, y] , ניתן לבצע איטרציה של אלמנטים ב- y=0 עבור כל x .

כל שינוי שהוחל על הפרוסה המוחזרת משפיע גם על הנתונים של מערך זה, מכיוון שאין עותק מעורב.

דוגמה לשימוש:

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
    });
 }

כתוב את התוכן של מערך N-ממדי זה ממאגר המקור.

גודל המאגר חייב להיות שווה או גדול יותר size() של מערך זה, או שיוצא חריג. לאחר ההעתקה, ניתן לשנות את התוכן של המאגר והמערך באופן עצמאי, מבלי להשפיע זה על זה.