Javascript khởi tạo mảng 2d

Julia, giống như hầu hết các ngôn ngữ tính toán kỹ thuật, cung cấp triển khai mảng hạng nhất. Hầu hết các ngôn ngữ tính toán kỹ thuật đều chú ý rất nhiều đến việc triển khai mảng của chúng với chi phí của các vùng chứa khác. Julia không xử lý mảng theo bất kỳ cách đặc biệt nào. Thư viện mảng được triển khai gần như hoàn toàn trong chính Julia và lấy hiệu suất của nó từ trình biên dịch, giống như bất kỳ mã nào khác được viết bằng Julia. Như vậy, cũng có thể xác định các loại mảng tùy chỉnh bằng cách kế thừa từ. Xem để biết thêm chi tiết về cách triển khai loại mảng tùy chỉnh

Mảng là một tập hợp các đối tượng được lưu trữ trong một lưới đa chiều. Mảng không chiều được cho phép, xem. Trong trường hợp chung nhất, một mảng có thể chứa các đối tượng kiểu. Đối với hầu hết các mục đích tính toán, mảng phải chứa các đối tượng thuộc loại cụ thể hơn, chẳng hạn như hoặc

Nói chung, không giống như nhiều ngôn ngữ tính toán kỹ thuật khác, Julia không mong đợi các chương trình được viết theo kiểu véc tơ để đạt được hiệu suất. Trình biên dịch của Julia sử dụng suy luận kiểu và tạo mã được tối ưu hóa để lập chỉ mục mảng vô hướng, cho phép các chương trình được viết theo kiểu thuận tiện và dễ đọc mà không làm giảm hiệu suất và đôi khi sử dụng ít bộ nhớ hơn

Ở Julia, tất cả các đối số của hàm là [i. e. bằng con trỏ]. Một số ngôn ngữ máy tính kỹ thuật truyền mảng theo giá trị và trong khi điều này ngăn việc sửa đổi ngẫu nhiên bởi callees của một giá trị trong trình gọi, nó khiến việc tránh sao chép mảng không mong muốn trở nên khó khăn. Theo quy ước, tên hàm kết thúc bằng

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

3 cho biết rằng nó sẽ thay đổi hoặc hủy giá trị của một hoặc nhiều đối số của nó [ví dụ: so sánh và ]. Người được gọi phải tạo bản sao rõ ràng để đảm bảo rằng họ không sửa đổi đầu vào mà họ không có ý định thay đổi. Nhiều chức năng không đột biến được triển khai bằng cách gọi một chức năng cùng tên với một

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

3 được thêm vào ở cuối trên một bản sao rõ ràng của đầu vào và trả lại bản sao đó

HàmMô tảloại phần tử chứa trong

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8số lượng phần tử trong

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8số lượng thứ nguyên của

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8a bộ chứa thứ nguyên của

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8kích thước của

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8 dọc theo thứ nguyên

julia> [1; 2;; 3; 4;; 5; 6;;;
        7; 8;; 9; 10;; 11; 12]
2×3×2 Array{Int64, 3}:
[:, :, 1] =
 1  3  5
 2  4  6

[:, :, 2] =
 7   9  11
 8  10  12

7a bộ chứa các chỉ số hợp lệ của

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8a phạm vi biểu thị các chỉ số hợp lệ dọc theo thứ nguyên

julia> [1; 2;; 3; 4;; 5; 6;;;
        7; 8;; 9; 10;; 11; 12]
2×3×2 Array{Int64, 3}:
[:, :, 1] =
 1  3  5
 2  4  6

[:, :, 2] =
 7   9  11
 8  10  12

7một bộ lặp hiệu quả để truy cập từng thứ nguyên

Nhiều chức năng để xây dựng và khởi tạo mảng được cung cấp. Trong danh sách các hàm như vậy sau đây, các lệnh gọi có đối số

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

17 có thể nhận một bộ kích thước kích thước duy nhất hoặc một loạt kích thước kích thước được truyền dưới dạng một số đối số thay đổi. Hầu hết các hàm này cũng chấp nhận đầu vào đầu tiên

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

18, là kiểu phần tử của mảng. Nếu loại

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

18 bị bỏ qua, nó sẽ mặc định là

FunctionDescriptionan dày đặc chưa khởi tạo một

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

52 trong số tất cả các số không,

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

52 trong số tất cả các số một, với tất cả các giá trị

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

59a

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

58 với tất cả các giá trị

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

92một mảng chứa cùng dữ liệu như

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8, nhưng với các kích thước khác nhau sao chép

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8sao chép

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8, sao chép đệ quy các phần tử của nómột mảng chưa khởi tạo của cùng một . ], nhưng với loại phần tử và kích thước được chỉ định. Đối số thứ hai và thứ ba đều là tùy chọn, mặc định là loại phần tử và kích thước của

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8 nếu bị bỏ qua. một mảng có cùng dữ liệu nhị phân như

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8, nhưng có loại phần tử

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

18an

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

52 với các giá trị ngẫu nhiên, iid và được phân phối đồng đều trong khoảng thời gian nửa mở $[0, 1]$một

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

52 với các giá trị ngẫu nhiên, iid và phân phối chuẩn chuẩn

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

910-by-

julia> [1; 2;; 3; 4;; 5; 6;;;
        7; 8;; 9; 10;; 11; 12]
2×3×2 Array{Int64, 3}:
[:, :, 1] =
 1  3  5
 2  4  6

[:, :, 2] =
 7   9  11
 8  10  12

7 ma trận đồng nhất. Yêu cầu

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

912 cho. một phạm vi gồm các phần tử khoảng cách tuyến tính của

julia> [1; 2;; 3; 4;; 5; 6;;;
        7; 8;; 9; 10;; 11; 12]
2×3×2 Array{Int64, 3}:
[:, :, 1] =
 1  3  5
 2  4  6

[:, :, 2] =
 7   9  11
 8  10  12

7 từ

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

916 đến

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

917 điền vào mảng

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8 với giá trị

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

920an

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

52 điền vào giá trị

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

920. Đặc biệt,

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

924 xây dựng một

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

52 không chiều chứa

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

920

Để xem các cách khác nhau mà chúng ta có thể truyền kích thước cho các hàm này, hãy xem xét các ví dụ sau

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

2

Ở đây,

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

927 là a và đối số đầu tiên — loại phần tử — là tùy chọn, mặc định là

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

1

Mảng cũng có thể được xây dựng trực tiếp với dấu ngoặc vuông; . e. , một vectơ] chứa các đối số được phân tách bằng dấu phẩy làm thành phần của nó. Loại phần tử [] của mảng kết quả được xác định tự động bởi các loại đối số bên trong dấu ngoặc nhọn. Nếu tất cả các đối số là cùng một loại, thì đó là

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

931. Nếu tất cả chúng đều có một điểm chung thì chúng sẽ được chuyển đổi thành loại đó bằng cách sử dụng và loại đó là

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

931 của mảng. Mặt khác, một mảng không đồng nhất có thể chứa bất kỳ thứ gì — một

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

935 — được tạo;

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

9

Nếu các đối số bên trong dấu ngoặc vuông được phân tách bằng dấu chấm phẩy đơn [

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

937] hoặc dòng mới thay vì dấu phẩy, thì nội dung của chúng được nối với nhau theo chiều dọc thay vì chính các đối số được sử dụng làm phần tử

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

2

Tương tự, nếu các đối số được phân tách bằng tab hoặc dấu cách hoặc dấu chấm phẩy kép, thì nội dung của chúng được nối theo chiều ngang với nhau

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

3

Dấu chấm phẩy đơn [hoặc dòng mới] và dấu cách [hoặc tab] có thể được kết hợp để nối cả chiều ngang và chiều dọc cùng một lúc

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

4

Dấu cách [và tab] có mức độ ưu tiên cao hơn dấu chấm phẩy, thực hiện bất kỳ phép nối ngang nào trước rồi mới nối kết quả. Mặt khác, sử dụng dấu chấm phẩy kép cho phép nối ngang, thực hiện bất kỳ phép nối dọc nào trước khi nối kết quả theo chiều ngang

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

Giống như

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

937 và

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

939 nối ở chiều thứ nhất và chiều thứ hai, việc sử dụng nhiều dấu chấm phẩy hơn sẽ mở rộng sơ đồ chung này. Số lượng dấu chấm phẩy trong dấu phân cách chỉ định thứ nguyên cụ thể, do đó,

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

940 nối trong thứ nguyên thứ ba,

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

941 trong thứ nguyên thứ 4, v.v. Ít dấu chấm phẩy được ưu tiên hơn, vì vậy các kích thước thấp hơn thường được nối trước

julia> [1; 2;; 3; 4;; 5; 6;;;
        7; 8;; 9; 10;; 11; 12]
2×3×2 Array{Int64, 3}:
[:, :, 1] =
 1  3  5
 2  4  6

[:, :, 2] =
 7   9  11
 8  10  12

Giống như trước đây, khoảng trắng [và tab] để nối theo chiều ngang có mức độ ưu tiên cao hơn bất kỳ số lượng dấu chấm phẩy nào. Do đó, các mảng chiều cao hơn cũng có thể được viết bằng cách chỉ định các hàng của chúng trước, với các phần tử của chúng được sắp xếp theo văn bản theo cách tương tự như bố cục của chúng.

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

1

Mặc dù cả hai đều có nghĩa là nối trong chiều thứ hai, khoảng trắng [hoặc tab] và

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

939 không thể xuất hiện trong cùng một biểu thức mảng trừ khi dấu chấm phẩy kép chỉ đóng vai trò là ký tự "tiếp tục dòng". Điều này cho phép một phép nối ngang duy nhất trải rộng trên nhiều dòng [không ngắt dòng được hiểu là nối dọc]

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

5

Dấu chấm phẩy kết thúc cũng có thể được sử dụng để thêm các thứ nguyên có độ dài 1 ở cuối

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

9

Tổng quát hơn, phép nối có thể được thực hiện thông qua hàm. Các cú pháp này là cách viết tắt của các lệnh gọi hàm mà bản thân chúng là các hàm tiện lợi

SyntaxFunctionDescription nối các mảng đầu vào dọc theo [các] chiều

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

15

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

946viết tắt của `cat[A. ; . ;

Một mảng với một loại phần tử cụ thể có thể được xây dựng bằng cú pháp

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

954. Điều này sẽ xây dựng một mảng 1-d với loại phần tử

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

18, được khởi tạo để chứa các phần tử

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8,

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

957,

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

958, v.v. Ví dụ:

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

959 xây dựng một mảng không đồng nhất có thể chứa bất kỳ giá trị nào

Tương tự, cú pháp nối có thể được thêm tiền tố vào một loại để chỉ định loại phần tử của kết quả

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

90

Sự hiểu biết cung cấp một cách tổng quát và mạnh mẽ để xây dựng các mảng. Cú pháp hiểu tương tự như ký hiệu xây dựng tập hợp trong toán học

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

91

Ý nghĩa của dạng này là

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

960 được đánh giá với các biến

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

920,

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

962, v.v. nhận từng giá trị trong danh sách giá trị đã cho của chúng. Các giá trị có thể được chỉ định là bất kỳ đối tượng có thể lặp lại nào, nhưng thường sẽ là các phạm vi như

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

963 hoặc

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

964 hoặc các mảng giá trị rõ ràng như

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

965. Kết quả là một mảng dày đặc N-d với các kích thước là sự nối các kích thước của các phạm vi biến

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

966,

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

967, v.v. và mỗi đánh giá

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

960 trả về một giá trị vô hướng

Ví dụ sau tính toán trung bình có trọng số của phần tử hiện tại và hàng xóm bên trái và bên phải của nó dọc theo lưới 1 chiều.

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

92

Kiểu mảng kết quả phụ thuộc vào kiểu của các phần tử được tính giống như do. Để kiểm soát loại một cách rõ ràng, một loại có thể được thêm vào phần hiểu. Ví dụ: chúng tôi có thể yêu cầu kết quả ở độ chính xác duy nhất bằng cách viết

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

93

Sự hiểu biết cũng có thể được viết mà không có dấu ngoặc vuông kèm theo, tạo ra một đối tượng được gọi là trình tạo. Đối tượng này có thể được lặp lại để tạo ra các giá trị theo yêu cầu, thay vì phân bổ một mảng và lưu trữ chúng trước [xem phần ]. Ví dụ: biểu thức sau tính tổng một chuỗi mà không cấp phát bộ nhớ

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

94

Khi viết biểu thức trình tạo có nhiều thứ nguyên bên trong danh sách đối số, cần có dấu ngoặc đơn để tách trình tạo khỏi các đối số tiếp theo

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

95

Tất cả các biểu thức được phân tách bằng dấu phẩy sau

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

969 được hiểu là phạm vi. Thêm dấu ngoặc đơn cho phép chúng tôi thêm đối số thứ ba vào

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

96

Trình tạo được thực hiện thông qua các chức năng bên trong. Giống như các hàm bên trong được sử dụng ở những nơi khác trong ngôn ngữ, các biến từ phạm vi kèm theo có thể được "bắt giữ" trong hàm bên trong. Ví dụ:

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

971 nắm bắt ba biến

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

972,

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

973 và

julia> [1; 2;; 3; 4;; 5; 6;;;
        7; 8;; 9; 10;; 11; 12]
2×3×2 Array{Int64, 3}:
[:, :, 1] =
 1  3  5
 2  4  6

[:, :, 2] =
 7   9  11
 8  10  12

7 từ phạm vi kèm theo. Các biến được chụp có thể đưa ra những thách thức về hiệu suất;

Phạm vi trong trình tạo và khả năng hiểu có thể phụ thuộc vào phạm vi trước đó bằng cách viết nhiều từ khóa

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

969

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

97

Trong những trường hợp như vậy, kết quả luôn là 1-d

Các giá trị đã tạo có thể được lọc bằng từ khóa

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

976

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

98

Cú pháp chung để lập chỉ mục cho mảng n chiều

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8 là

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

99

trong đó mỗi

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

978 có thể là một số nguyên vô hướng, một mảng các số nguyên hoặc bất kỳ số nào khác. Điều này bao gồm [

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

980] để chọn tất cả các chỉ số trong toàn bộ thứ nguyên, phạm vi của biểu mẫu

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

981 hoặc

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

982 để chọn các phần phụ liền kề hoặc phân tầng và các mảng booleans để chọn các phần tử tại chỉ mục

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

59 của chúng

Nếu tất cả các chỉ số là vô hướng, thì kết quả

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

984 là một phần tử duy nhất từ ​​mảng

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8. Mặt khác,

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

984 là một mảng có cùng số chiều với tổng các chiều của tất cả các chỉ số

Ví dụ: nếu tất cả các chỉ số

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

978 đều là vectơ, thì hình dạng của

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

984 sẽ là

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

989, với vị trí

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

990 của

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

984 chứa giá trị

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

992

Ví dụ

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

20

Lưu ý kích thước của mảng kết quả khác nhau như thế nào trong hai trường hợp cuối cùng

Nếu đổi

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

993 thành ma trận hai chiều thì

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

984 trở thành mảng chiều

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

995 có hình dạng

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

996. Ma trận thêm một thứ nguyên

Ví dụ

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

21

Vị trí

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

997 chứa giá trị tại

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

998. Tất cả các kích thước được lập chỉ mục với vô hướng đều bị loại bỏ. Ví dụ: nếu

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

999 là một mảng các chỉ số, thì kết quả của

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

200 là một mảng có kích thước

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

201. Phần tử thứ

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

202 của nó được điền bởi

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

203

Là một phần đặc biệt của cú pháp này, từ khóa

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

204 có thể được sử dụng để biểu thị chỉ mục cuối cùng của mỗi thứ nguyên trong dấu ngoặc đơn, được xác định bởi kích thước của mảng trong cùng được lập chỉ mục. Cú pháp lập chỉ mục không có từ khóa

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

204 tương đương với một cuộc gọi đến

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

22

Ví dụ

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

23

Cú pháp chung để gán giá trị trong mảng n chiều

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8 là

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

24

trong đó mỗi

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

978 có thể là một số nguyên vô hướng, một mảng các số nguyên hoặc bất kỳ số nào khác. Điều này bao gồm [

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

980] để chọn tất cả các chỉ số trong toàn bộ thứ nguyên, phạm vi của biểu mẫu

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

981 hoặc

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

982 để chọn các phần phụ liền kề hoặc phân tầng và các mảng booleans để chọn các phần tử tại chỉ mục

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

59 của chúng

Nếu tất cả các chỉ số

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

978 là số nguyên, thì giá trị ở vị trí

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

215 của

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8 được ghi đè bằng giá trị của

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

984, chuyển sang vị trí của

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8 nếu cần

Nếu bất kỳ chỉ mục nào

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

978 tự nó là một mảng, thì phía bên tay phải của

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

984 cũng phải là một mảng có cùng hình dạng như kết quả của việc lập chỉ mục

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

223 hoặc một vectơ có cùng số phần tử. Giá trị ở vị trí

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

224 của

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8 được ghi đè bằng giá trị

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

226, chuyển đổi nếu cần. Toán tử gán phần tử khôn ngoan

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

227 có thể được sử dụng để

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

984 trên các vị trí đã chọn

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

25

Cũng giống như trong , từ khóa

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

204 có thể được sử dụng để biểu thị chỉ mục cuối cùng của mỗi thứ nguyên trong dấu ngoặc đơn, như được xác định bởi kích thước của mảng được gán vào. Cú pháp gán được lập chỉ mục không có từ khóa

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

204 tương đương với một cuộc gọi đến

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

26

Ví dụ

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

27

Trong biểu thức

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

223, mỗi

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

978 có thể là một chỉ số vô hướng, một mảng các chỉ số vô hướng hoặc một đối tượng đại diện cho một mảng các chỉ số vô hướng và có thể được chuyển đổi thành như vậy bằng cách

1. một chỉ số vô hướng. Theo mặc định, điều này bao gồm
   • Số nguyên không phải boolean
   • s, hoạt động giống như một bộ số nguyên

     julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
     3×3 Matrix{Int64}:
      0  0  1
      0  0  2
      3  4  5
     
     julia> [1:2; 4;; 1; 3:4]
     3×2 Matrix{Int64}:
      1  1
      2  3
      4  4

     236 bao trùm nhiều chiều [xem bên dưới để biết thêm chi tiết]
2. Một mảng các chỉ số vô hướng. Điêu nay bao gôm
   • Vectơ và mảng nhiều chiều của số nguyên
   • Các mảng trống như

     julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
     3×3 Matrix{Int64}:
      0  0  1
      0  0  2
      3  4  5
     
     julia> [1:2; 4;; 1; 3:4]
     3×2 Matrix{Int64}:
      1  1
      2  3
      4  4

     936, không chọn phần tử nào
   • Các phạm vi như

     julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
     3×3 Matrix{Int64}:
      0  0  1
      0  0  2
      3  4  5
     
     julia> [1:2; 4;; 1; 3:4]
     3×2 Matrix{Int64}:
      1  1
      2  3
      4  4

     981 hoặc

     julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
     3×3 Matrix{Int64}:
      0  0  1
      0  0  2
      3  4  5
     
     julia> [1:2; 4;; 1; 3:4]
     3×2 Matrix{Int64}:
      1  1
      2  3
      4  4

     982, chọn các tiểu mục liền kề hoặc nối tiếp nhau từ

     julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
     3×3 Matrix{Int64}:
      0  0  1
      0  0  2
      3  4  5
     
     julia> [1:2; 4;; 1; 3:4]
     3×2 Matrix{Int64}:
      1  1
      2  3
      4  4

     240 đến

     julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
     3×3 Matrix{Int64}:
      0  0  1
      0  0  2
      3  4  5
     
     julia> [1:2; 4;; 1; 3:4]
     3×2 Matrix{Int64}:
      1  1
      2  3
      4  4

     241 [bao gồm]
   • Bất kỳ mảng tùy chỉnh nào của các chỉ số vô hướng là một kiểu con của

     julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
     3×3 Matrix{Int64}:
      0  0  1
      0  0  2
      3  4  5
     
     julia> [1:2; 4;; 1; 3:4]
     3×2 Matrix{Int64}:
      1  1
      2  3
      4  4

     49
   • Mảng của

     julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
     3×3 Matrix{Int64}:
      0  0  1
      0  0  2
      3  4  5
     
     julia> [1:2; 4;; 1; 3:4]
     3×2 Matrix{Int64}:
      1  1
      2  3
      4  4

     235 [xem bên dưới để biết thêm chi tiết]
3. Một đối tượng đại diện cho một mảng các chỉ số vô hướng và có thể được chuyển đổi thành như vậy bằng cách. Theo mặc định, điều này bao gồm
   • [

     julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
     3×3 Matrix{Int64}:
      0  0  1
      0  0  2
      3  4  5
     
     julia> [1:2; 4;; 1; 3:4]
     3×2 Matrix{Int64}:
      1  1
      2  3
      4  4

     980], đại diện cho tất cả các chỉ số trong toàn bộ thứ nguyên hoặc trên toàn bộ mảng
   • Mảng booleans, chọn các phần tử tại chỉ số

     julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
     3×3 Matrix{Int64}:
      0  0  1
      0  0  2
      3  4  5
     
     julia> [1:2; 4;; 1; 3:4]
     3×2 Matrix{Int64}:
      1  1
      2  3
      4  4

     59 của chúng [xem bên dưới để biết thêm chi tiết]

Vài ví dụ

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

28

Đối tượng đặc biệt

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

235 đại diện cho một chỉ mục vô hướng hoạt động giống như một bộ số nguyên

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

236 bao trùm nhiều chiều. Ví dụ

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

29

Nếu xét riêng, điều này có vẻ tương đối tầm thường; . Tuy nhiên, khi được kết hợp với các biểu mẫu lập chỉ mục và trình vòng lặp khác mang lại

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

250es, điều này có thể tạo ra mã rất thanh lịch và hiệu quả. Xem bên dưới và để biết một số ví dụ nâng cao hơn, hãy xem bài đăng trên blog này về các thuật toán và phép lặp đa chiều

Mảng của

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

235 cũng được hỗ trợ. Chúng đại diện cho một tập hợp các chỉ số vô hướng mà mỗi chiều dài khoảng 5236 chiều, cho phép một hình thức lập chỉ mục đôi khi được gọi là lập chỉ mục theo điểm. Ví dụ: nó cho phép truy cập các phần tử đường chéo từ "trang" đầu tiên của

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8 từ phía trên

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

30

Điều này có thể được thể hiện đơn giản hơn nhiều với và bằng cách kết hợp nó với một chỉ số nguyên thông thường [thay vì trích xuất

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

255 đầu tiên từ

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8 như một bước riêng biệt]. Nó thậm chí có thể được kết hợp với một

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

980 để trích xuất cả hai đường chéo từ hai trang cùng một lúc

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

31

Cảnh báo

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

250 và mảng của

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

250 không tương thích với từ khóa

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

204 để biểu thị chỉ mục cuối cùng của thứ nguyên. Không sử dụng

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

204 trong các biểu thức lập chỉ mục có thể chứa

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

250 hoặc các mảng của chúng

Thường được gọi là lập chỉ mục logic hoặc lập chỉ mục với mặt nạ logic, lập chỉ mục bằng một mảng boolean chọn các phần tử tại các chỉ mục có giá trị của nó là

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

59. Lập chỉ mục theo vectơ boolean

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

957 thực sự giống như lập chỉ mục theo vectơ số nguyên được trả về bởi. Tương tự, lập chỉ mục theo mảng boolean chiều

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

236 thực sự giống như lập chỉ mục theo vectơ của

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

235 trong đó các giá trị của nó là

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

59. Chỉ mục logic phải là một vectơ có cùng độ dài với thứ nguyên mà nó lập chỉ mục hoặc nó phải là chỉ mục duy nhất được cung cấp và khớp với kích thước và chiều của mảng mà nó lập chỉ mục vào. Nói chung sẽ hiệu quả hơn khi sử dụng trực tiếp các mảng boolean làm chỉ mục thay vì gọi trước

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

32

Cách thông thường để lập chỉ mục thành một mảng 5236 chiều ________ là sử dụng chính xác 5236 chỉ mục; . Ví dụ, trong mảng ba chiều

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

272,

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

273 sẽ chọn số ở hàng thứ hai của cột thứ ba trong "trang" đầu tiên của mảng. Điều này thường được gọi là lập chỉ mục cartesian

Khi chính xác một chỉ mục

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

274 được cung cấp, chỉ mục đó không còn đại diện cho một vị trí trong một chiều cụ thể của mảng. Thay vào đó, nó chọn phần tử thứ

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

274 bằng cách sử dụng thứ tự lặp lại chính của cột kéo dài tuyến tính toàn bộ mảng. Điều này được gọi là lập chỉ mục tuyến tính. Về cơ bản, nó xử lý mảng như thể nó đã được định hình lại thành một vectơ một chiều với

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

33

Một chỉ mục tuyến tính trong mảng

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8 có thể được chuyển đổi thành một

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

250 để lập chỉ mục cartesian với

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

279 [xem ] và một tập hợp các chỉ số cartesian

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

236 có thể được chuyển đổi thành một chỉ mục tuyến tính với

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

282 [xem ]

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

34

Điều quan trọng cần lưu ý là có sự bất đối xứng rất lớn trong hiệu suất của các chuyển đổi này. Chuyển đổi một chỉ số tuyến tính thành một tập hợp các chỉ số cartesian yêu cầu chia và lấy phần còn lại, trong khi đi theo cách khác chỉ là nhân và cộng. Trong các bộ xử lý hiện đại, phép chia số nguyên có thể chậm hơn 10-50 lần so với phép nhân. Trong khi một số mảng - giống như chính nó - được triển khai bằng cách sử dụng một đoạn bộ nhớ tuyến tính và sử dụng trực tiếp chỉ mục tuyến tính trong quá trình triển khai của chúng, thì các mảng khác - như - cần có bộ chỉ số cartesian đầy đủ để thực hiện tra cứu [xem nội quan cái nào]. Như vậy, khi lặp lại toàn bộ mảng, tốt hơn hết là lặp lại thay vì

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

288. Cái trước không chỉ nhanh hơn nhiều trong trường hợp

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8 là

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

290 mà còn hỗ trợ OffsetArrays nữa

Ngoài lập chỉ mục tuyến tính, một mảng chiều

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

236 có thể được lập chỉ mục với ít hơn hoặc nhiều hơn chỉ mục

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

236 trong một số trường hợp nhất định

Các chỉ số có thể được bỏ qua nếu các thứ nguyên theo sau không được lập chỉ mục đều có độ dài một. Nói cách khác, các chỉ mục theo sau chỉ có thể được bỏ qua nếu chỉ có một giá trị khả dĩ mà các chỉ mục bị bỏ qua đó có thể dành cho một biểu thức lập chỉ mục trong giới hạn. Ví dụ: một mảng bốn chiều có kích thước

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

293 có thể được lập chỉ mục chỉ với ba chỉ số vì thứ nguyên bị bỏ qua [thứ nguyên thứ tư] có độ dài bằng một. Lưu ý rằng lập chỉ mục tuyến tính được ưu tiên hơn quy tắc này

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

35

Khi bỏ qua tất cả các chỉ mục với

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

294, ngữ nghĩa này cung cấp một thành ngữ đơn giản để truy xuất phần tử duy nhất trong một mảng và đồng thời đảm bảo rằng chỉ có một phần tử

Tương tự, có thể cung cấp nhiều hơn

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

236 chỉ số nếu tất cả các chỉ số nằm ngoài thứ nguyên của mảng là

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

296 [hoặc tổng quát hơn là phần tử đầu tiên và duy nhất của

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

297 trong đó

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

298 là số thứ nguyên cụ thể đó]. Điều này cho phép các vectơ được lập chỉ mục giống như ma trận một cột, chẳng hạn

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

36

Các cách được đề xuất để lặp lại toàn bộ mảng là

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

37

Cấu trúc đầu tiên được sử dụng khi bạn cần giá trị, nhưng không phải chỉ mục, của từng phần tử. Trong cấu trúc thứ hai,

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

274 sẽ là một

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

300 nếu

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8 là một kiểu mảng có lập chỉ mục tuyến tính nhanh;

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

38

Ngược lại với

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

303, lặp với cung cấp một cách hiệu quả để lặp trên bất kỳ loại mảng nào

Nếu bạn viết một loại tùy chỉnh, bạn có thể chỉ định rằng nó có lập chỉ mục tuyến tính nhanh bằng cách sử dụng

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

39

Cài đặt này sẽ khiến phép lặp

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

304 trên một

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

307 sử dụng số nguyên. Nếu bạn không chỉ định đặc điểm này, giá trị mặc định

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

308 sẽ được sử dụng

Các toán tử sau được hỗ trợ cho mảng

1. Số học một ngôi –

   julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
   3×3 Matrix{Int64}:
    0  0  1
    0  0  2
    3  4  5
   
   julia> [1:2; 4;; 1; 3:4]
   3×2 Matrix{Int64}:
    1  1
    2  3
    4  4

   309,

   julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
   3×3 Matrix{Int64}:
    0  0  1
    0  0  2
    3  4  5
   
   julia> [1:2; 4;; 1; 3:4]
   3×2 Matrix{Int64}:
    1  1
    2  3
    4  4

   310
2. Số học nhị phân –

   julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
   3×3 Matrix{Int64}:
    0  0  1
    0  0  2
    3  4  5
   
   julia> [1:2; 4;; 1; 3:4]
   3×2 Matrix{Int64}:
    1  1
    2  3
    4  4

   309,

   julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
   3×3 Matrix{Int64}:
    0  0  1
    0  0  2
    3  4  5
   
   julia> [1:2; 4;; 1; 3:4]
   3×2 Matrix{Int64}:
    1  1
    2  3
    4  4

   310,

   julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
   3×3 Matrix{Int64}:
    0  0  1
    0  0  2
    3  4  5
   
   julia> [1:2; 4;; 1; 3:4]
   3×2 Matrix{Int64}:
    1  1
    2  3
    4  4

   313,

   julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
   3×3 Matrix{Int64}:
    0  0  1
    0  0  2
    3  4  5
   
   julia> [1:2; 4;; 1; 3:4]
   3×2 Matrix{Int64}:
    1  1
    2  3
    4  4

   314,

   julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
   3×3 Matrix{Int64}:
    0  0  1
    0  0  2
    3  4  5
   
   julia> [1:2; 4;; 1; 3:4]
   3×2 Matrix{Int64}:
    1  1
    2  3
    4  4

   315,

   julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
   3×3 Matrix{Int64}:
    0  0  1
    0  0  2
    3  4  5
   
   julia> [1:2; 4;; 1; 3:4]
   3×2 Matrix{Int64}:
    1  1
    2  3
    4  4

   316
3. So sánh –

   julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
   3×3 Matrix{Int64}:
    0  0  1
    0  0  2
    3  4  5
   
   julia> [1:2; 4;; 1; 3:4]
   3×2 Matrix{Int64}:
    1  1
    2  3
    4  4

   317,

   julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
   3×3 Matrix{Int64}:
    0  0  1
    0  0  2
    3  4  5
   
   julia> [1:2; 4;; 1; 3:4]
   3×2 Matrix{Int64}:
    1  1
    2  3
    4  4

   318,

   julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
   3×3 Matrix{Int64}:
    0  0  1
    0  0  2
    3  4  5
   
   julia> [1:2; 4;; 1; 3:4]
   3×2 Matrix{Int64}:
    1  1
    2  3
    4  4

   319 [],

   julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
   3×3 Matrix{Int64}:
    0  0  1
    0  0  2
    3  4  5
   
   julia> [1:2; 4;; 1; 3:4]
   3×2 Matrix{Int64}:
    1  1
    2  3
    4  4

   321

Để cho phép vector hóa thuận tiện các phép toán và các phép toán khác, Julia

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

322, e. g.

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

323 hoặc

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

324, đối với các phép toán theo nguyên tố trên mảng hoặc hỗn hợp của mảng và vô hướng [một phép toán]; . g.

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

325

Ngoài ra, mọi toán tử nhị phân đều hỗ trợ a có thể được áp dụng cho mảng [và sự kết hợp của mảng và vô hướng] theo cách như vậy, e. g.

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

326

Lưu ý rằng các so sánh như

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

317 hoạt động trên toàn bộ mảng, đưa ra một câu trả lời boolean duy nhất. Sử dụng các toán tử dấu chấm như

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

328 để so sánh theo từng phần tử. [Đối với các hoạt động so sánh như

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

329, chỉ phiên bản

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

330 theo phần tử được áp dụng cho mảng. ]

Cũng lưu ý sự khác biệt giữa

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

331, theo từng phần tử so với

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

240 và

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

335, và , tìm thấy giá trị lớn nhất trong phạm vi

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

240. Mối quan hệ tương tự giữ cho

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

338 và

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

339

Đôi khi rất hữu ích khi thực hiện các phép toán nhị phân theo từng phần tử trên các mảng có kích thước khác nhau, chẳng hạn như thêm một vectơ vào mỗi cột của ma trận. Một cách không hiệu quả để làm điều này là sao chép vectơ theo kích thước của ma trận

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

40

Điều này là lãng phí khi các kích thước trở nên lớn, vì vậy Julia cung cấp , mở rộng các kích thước đơn lẻ trong các đối số mảng để khớp với kích thước tương ứng trong mảng khác mà không cần sử dụng thêm bộ nhớ và áp dụng hàm đã cho theo từng phần tử

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

41

chẳng hạn như

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

341 và

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

342 tương đương với các cuộc gọi

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

332 [ngoại trừ việc chúng hợp nhất, như ]. Ngoài ra còn có một chức năng để chỉ định một đích rõ ràng [cũng có thể được truy cập theo kiểu hợp nhất bằng cách gán

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

227]. Trên thực tế,

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

322 tương đương với

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

347, cung cấp một cú pháp thuận tiện để quảng bá bất kỳ chức năng nào []. Lồng các "cuộc gọi dấu chấm"

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

348 [bao gồm các cuộc gọi đến

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

341, v.v.] vào một cuộc gọi

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

332 duy nhất

Ngoài ra, không giới hạn đối với mảng [xem tài liệu về chức năng]; . Theo mặc định, chỉ một số loại đối số được coi là vô hướng, bao gồm [nhưng không giới hạn ở]

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

352,

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

353,

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

354,

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

355,

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

356 và một số đối số đơn phổ biến như

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

357 và

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

358. Tất cả các đối số khác được lặp lại hoặc lập chỉ mục thành phần tử

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

42

Đôi khi, bạn muốn một vùng chứa [như một mảng] thường tham gia phát sóng được "bảo vệ" khỏi hành vi lặp lại của phát sóng trên tất cả các phần tử của nó. Bằng cách đặt nó bên trong một thùng chứa khác [như một phần tử đơn lẻ], quảng bá sẽ coi nó là một giá trị duy nhất

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

43

Kiểu mảng cơ sở trong Julia là kiểu trừu tượng. Nó được tham số hóa bởi số thứ nguyên

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

236 và loại phần tử

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

18. và là bí danh cho các trường hợp 1-d và 2-d. Các thao tác trên các đối tượng

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

49 được xác định bằng cách sử dụng các hàm và toán tử cấp cao hơn, theo cách độc lập với bộ lưu trữ bên dưới. Các hoạt động này thường hoạt động chính xác dưới dạng dự phòng cho bất kỳ triển khai mảng cụ thể nào

Loại

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

49 bao gồm bất kỳ thứ gì giống như mảng một cách mơ hồ và việc triển khai nó có thể khá khác so với các mảng thông thường. Ví dụ: các phần tử có thể được tính toán theo yêu cầu thay vì được lưu trữ. Tuy nhiên, bất kỳ loại

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

360 cụ thể nào thường phải triển khai ít nhất [trả về một bộ dữ liệu

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

300] và ; . Chúng tôi khuyến nghị rằng các thao tác này có độ phức tạp về thời gian gần như không đổi, vì nếu không, một số hàm mảng có thể bị chậm bất ngờ. Các loại cụ thể cũng thường cung cấp một phương thức, được sử dụng để phân bổ một mảng tương tự cho và các hoạt động không đúng chỗ khác. Bất kể một

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

360 được biểu diễn bên trong như thế nào, thì

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

18 là loại đối tượng được trả về bằng cách lập chỉ mục số nguyên [

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

377, khi

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8 không trống] và

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

236 phải là độ dài của bộ được trả về bởi. Để biết thêm chi tiết về việc xác định triển khai

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

49 tùy chỉnh, hãy xem phần

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

382 là một kiểu con trừu tượng của

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

49 nhằm bao gồm tất cả các mảng trong đó các phần tử được lưu trữ liên tục theo thứ tự chính của cột [xem phần ]. Loại này là một phiên bản cụ thể của

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

382; . Rất ít hoạt động được triển khai cụ thể cho

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

52 ngoài những hoạt động được yêu cầu cho tất cả các

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

49;

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

390 là một chuyên môn hóa của

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

49 thực hiện lập chỉ mục bằng cách chia sẻ bộ nhớ với mảng ban đầu thay vì sao chép nó. Một

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

390 được tạo bằng hàm, được gọi theo cách tương tự như [với một mảng và một loạt đối số chỉ mục]. Kết quả của trông giống như kết quả của , ngoại trừ dữ liệu được giữ nguyên. lưu trữ các vectơ chỉ mục đầu vào trong một đối tượng

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

390, sau này có thể được sử dụng để lập chỉ mục mảng ban đầu một cách gián tiếp. Bằng cách đặt macro trước một biểu thức hoặc khối mã, bất kỳ lát cắt

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

400 nào trong biểu thức đó sẽ được chuyển đổi để tạo một dạng xem

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

390 thay thế

s là các mảng boolean "được đóng gói" tiết kiệm không gian, lưu trữ một bit cho mỗi giá trị boolean. Chúng có thể được sử dụng tương tự như mảng

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

403 [lưu trữ một byte cho mỗi giá trị boolean] và có thể được chuyển đổi sang/từ mảng sau thông qua

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

404 và

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

405, tương ứng

Một mảng được "strided" nếu nó được lưu trữ trong bộ nhớ với các khoảng cách được xác định rõ [sải] giữa các phần tử của nó. Một mảng có sải chân với loại phần tử được hỗ trợ có thể được chuyển đến thư viện bên ngoài [không phải Julia] như BLAS hoặc LAPACK bằng cách chuyển nó và sải chân cho mỗi thứ nguyên. Là khoảng cách giữa các phần tử dọc theo chiều

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

298. Ví dụ: nội dung dựng sẵn

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

52 được trả về bởi

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

410 có các phần tử của nó được sắp xếp liền kề theo thứ tự chính của cột. Điều này có nghĩa là sải chân của thứ nguyên đầu tiên — khoảng cách giữa các phần tử trong cùng một cột — là

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

296

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

44

Bước tiến của chiều thứ hai là khoảng cách giữa các phần tử trong cùng một hàng, bỏ qua số phần tử bằng với số phần tử trong một cột [

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

412]. Tương tự, chuyển giữa hai "trang" [ở chiều thứ ba] yêu cầu bỏ qua các phần tử

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

413. Của mảng này là bộ của ba số này với nhau

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

45

Trong trường hợp cụ thể này, số phần tử bị bỏ qua trong bộ nhớ khớp với số chỉ số tuyến tính bị bỏ qua. Đây chỉ là trường hợp đối với các mảng liền kề như

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

52 [và các kiểu con

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

382 khác] và nói chung là không đúng. Các dạng xem có chỉ số phạm vi là một ví dụ điển hình về các mảng có cấu trúc không liền kề; . Chế độ xem này

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

418 đề cập đến cùng một bộ nhớ như

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8 nhưng đang bỏ qua và sắp xếp lại một số thành phần của nó. Bước tiến của chiều đầu tiên của

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

418 là

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

421 vì chúng tôi chỉ chọn mỗi hàng thứ ba từ mảng ban đầu của chúng tôi

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

46

Chế độ xem này đang chọn tương tự mọi cột khác từ

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8 ban đầu của chúng tôi — và do đó, nó cần bỏ qua phần tương đương của hai cột năm phần tử khi di chuyển giữa các chỉ mục trong chiều thứ hai

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

47

Chiều thứ ba thú vị vì thứ tự của nó bị đảo ngược. Do đó, để chuyển từ "trang" đầu tiên sang trang thứ hai, nó phải quay ngược lại trong bộ nhớ và do đó, bước tiến của nó trong chiều này là âm

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

48

Điều này có nghĩa là

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

406 cho

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

418 thực sự đang trỏ vào giữa khối bộ nhớ của

julia> [zeros[Int, 2, 2] ; [3 4] ;; [1; 2] ; 5]
3×3 Matrix{Int64}:
 0  0  1
 0  0  2
 3  4  5

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

8 và nó đề cập đến các phần tử cả ngược và xuôi trong bộ nhớ. Xem để biết thêm chi tiết về cách xác định các mảng có cấu trúc của riêng bạn. và là các bí danh thuận tiện cho nhiều loại mảng dựng sẵn được coi là mảng có bước, cho phép chúng gửi đi để chọn các triển khai chuyên biệt gọi các hàm BLAS và LAPACK được điều chỉnh và tối ưu hóa cao chỉ bằng cách sử dụng con trỏ và các bước

Điều đáng nhấn mạnh là các bước tiến là về sự bù đắp trong bộ nhớ hơn là lập chỉ mục. Nếu bạn đang muốn chuyển đổi giữa lập chỉ mục tuyến tính [chỉ mục đơn] và lập chỉ mục cartesian [đa chỉ mục], hãy xem và