CompareEqual

Thực hiện so sánh tuyệt đối giữa hai ma trận bằng cách trải các hàng liên tiếp thành các vector một chiều.

ulong vector::Compare(
  const vector& vec    // vector để so sánh
   );
 
ulong matrix::CompareEqual(
  const matrix& mat     // ma trận để so sánh
   );

Tham số

vec

[in] Vector để so sánh.

mat

[in] Ma trận để so sánh.

Mô tả phương thức

Giả sử chúng ta có hai ma trận: ma trận A mà phương thức được gọi và ma trận B, được truyền làm tham số của phương thức. Việc so sánh được thực hiện như sau:

1. Các ma trận được mở rộng thành các vector một chiều bằng cách nối liên tiếp các hàng.
2. Các vector được so sánh từng phần tử cho đến khi gặp phần tử đầu tiên không khớp.
3. Tùy thuộc vào kết quả so sánh, một trong những giá trị được mô tả dưới đây sẽ được trả về.

Giá trị trả về

-1 — nếu phần tử của ma trận A nhỏ hơn phần tử tương ứng của ma trận B.

0 — nếu tất cả các phần tử của ma trận A và B giống nhau.

1 — nếu phần tử của ma trận A lớn hơn phần tử tương ứng của ma trận B.

Ghi chú

Các phần tử có giá trị NaN được tính đến khi so sánh.

Các phần tử có giá trị NaN được coi là bằng nhau nếu chúng xuất hiện ở cùng vị trí trong cả hai ma trận.

Dấu của NaN không được tính đến trong quá trình so sánh.

Một phần tử có giá trị NaN được coi là nhỏ hơn bất kỳ giá trị số nào khác.

Ví dụ

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   matrix matrix_a= {{10, 3, 2}, {1, 8, 12}, {6, 5, 4}};
   matrix matrix_i=matrix::Identity(3, 3);
   matrix matrix_c=matrix_a.Inv();
   matrix matrix_check=matrix_a.MatMul(matrix_c);
   Print("matrix_check\n", matrix_check);
 
   ulong errors=matrix_check.Compare(matrix::Identity(3, 3), 1e-15);
   Print("errors=", errors);
   /*
   matrix_check
   [[1,0,0]
   [4.440892098500626e-16,1,8.881784197001252e-16]
   [4.440892098500626e-16,2.220446049250313e-16,0.9999999999999996]]
   errors=0
   */
 
//--- so sánh tuyệt đối của các ma trận 
   matrix<double> A = matrix_a;  // Khởi tạo ma trận A
   matrix<double> B = matrix_c;  // Khởi tạo ma trận B
   int result = A.CompareEqual(B);
   switch(result)
     {
      case -1:
         Print("Ma trận A nhỏ hơn ma trận B");
         break;
      case 0:
         Print("Ma trận A và B giống nhau");
         break;
      case 1:
         Print("Ma trận A lớn hơn ma trận B");
         break;
      case -2:
         Print("Lỗi! Ma trận A chưa được khởi tạo");
         break;
      case 2:
         Print("Lỗi! Ma trận B chưa được khởi tạo");
         break;
      case -3:
         Print("Lỗi! Kích thước của ma trận A nhỏ hơn kích thước của ma trận B");
         break;
      case 3:
         Print("Lỗi! Kích thước của ma trận A lớn hơn kích thước của ma trận B");
         break;
      default:
         Print("Lỗi! Lỗi không xác định");
         break;
     }
  }