go.charczuk.com@v0.0.0-20240327042549-bc490516bd1a/sdk/matrix/matrix_test.go (about)

     1  /*
     2  
     3  Copyright (c) 2024 - Present. Will Charczuk. All rights reserved.
     4  Use of this source code is governed by a MIT license that can be found in the LICENSE file at the root of the repository.
     5  
     6  */
     7  
     8  package matrix
     9  
    10  import (
    11  	"testing"
    12  
    13  	"go.charczuk.com/sdk/assert"
    14  )
    15  
    16  func Test_New(t *testing.T) {
    17  	m := New(10, 5)
    18  	rows, cols := m.Size()
    19  	assert.ItsEqual(t, 10, rows)
    20  	assert.ItsEqual(t, 5, cols)
    21  	assert.ItsZero(t, m.Get(0, 0))
    22  	assert.ItsZero(t, m.Get(9, 4))
    23  }
    24  
    25  func Test_NewWithValues(t *testing.T) {
    26  	m := New(5, 2, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)
    27  	rows, cols := m.Size()
    28  	assert.ItsEqual(t, 5, rows)
    29  	assert.ItsEqual(t, 2, cols)
    30  	assert.ItsEqual(t, 1, m.Get(0, 0))
    31  	assert.ItsEqual(t, 10, m.Get(4, 1))
    32  }
    33  
    34  func Test_Identitiy(t *testing.T) {
    35  	id := Identity(5)
    36  	rows, cols := id.Size()
    37  	assert.ItsEqual(t, 5, rows)
    38  	assert.ItsEqual(t, 5, cols)
    39  	assert.ItsEqual(t, 1, id.Get(0, 0))
    40  	assert.ItsEqual(t, 1, id.Get(1, 1))
    41  	assert.ItsEqual(t, 1, id.Get(2, 2))
    42  	assert.ItsEqual(t, 1, id.Get(3, 3))
    43  	assert.ItsEqual(t, 1, id.Get(4, 4))
    44  	assert.ItsEqual(t, 0, id.Get(0, 1))
    45  	assert.ItsEqual(t, 0, id.Get(1, 0))
    46  	assert.ItsEqual(t, 0, id.Get(4, 0))
    47  	assert.ItsEqual(t, 0, id.Get(0, 4))
    48  }
    49  
    50  func Test_NewFromArrays(t *testing.T) {
    51  	m := NewFromArrays([][]float64{
    52  		{1, 2, 3, 4},
    53  		{5, 6, 7, 8},
    54  	})
    55  	assert.ItsNotNil(t, m)
    56  
    57  	rows, cols := m.Size()
    58  	assert.ItsEqual(t, 2, rows)
    59  	assert.ItsEqual(t, 4, cols)
    60  }
    61  
    62  func Test_Ones(t *testing.T) {
    63  	ones := Ones(5, 10)
    64  	rows, cols := ones.Size()
    65  	assert.ItsEqual(t, 5, rows)
    66  	assert.ItsEqual(t, 10, cols)
    67  
    68  	for row := 0; row < rows; row++ {
    69  		for col := 0; col < cols; col++ {
    70  			assert.ItsEqual(t, 1, ones.Get(row, col))
    71  		}
    72  	}
    73  }
    74  
    75  func Test_Matrix_WithEpsilon(t *testing.T) {
    76  	ones := Ones(2, 2)
    77  	ones = ones.WithEpsilon(0.001)
    78  	assert.ItsEqual(t, 0.001, ones.Epsilon())
    79  }
    80  
    81  func Test_Matrix_Arrays(t *testing.T) {
    82  	m := NewFromArrays([][]float64{
    83  		{1, 2, 3},
    84  		{4, 5, 6},
    85  	})
    86  
    87  	assert.ItsNotNil(t, m)
    88  
    89  	arrays := m.Arrays()
    90  
    91  	assert.ItsEqual(t, arrays, [][]float64{
    92  		{1, 2, 3},
    93  		{4, 5, 6},
    94  	})
    95  }
    96  
    97  func Test_Matrix_IsSquare(t *testing.T) {
    98  	assert.ItsFalse(t, NewFromArrays([][]float64{
    99  		{1, 2, 3},
   100  		{4, 5, 6},
   101  	}).IsSquare())
   102  
   103  	assert.ItsFalse(t, NewFromArrays([][]float64{
   104  		{1, 2},
   105  		{3, 4},
   106  		{5, 6},
   107  	}).IsSquare())
   108  
   109  	assert.ItsTrue(t, NewFromArrays([][]float64{
   110  		{1, 2},
   111  		{3, 4},
   112  	}).IsSquare())
   113  }
   114  
   115  func Test_Matrix_IsSymmetric(t *testing.T) {
   116  	assert.ItsFalse(t, NewFromArrays([][]float64{
   117  		{1, 2, 3},
   118  		{2, 1, 2},
   119  	}).IsSymmetric())
   120  
   121  	assert.ItsFalse(t, NewFromArrays([][]float64{
   122  		{1, 2, 3},
   123  		{4, 5, 6},
   124  		{7, 8, 9},
   125  	}).IsSymmetric())
   126  
   127  	assert.ItsTrue(t, NewFromArrays([][]float64{
   128  		{1, 2, 3},
   129  		{2, 1, 2},
   130  		{3, 2, 1},
   131  	}).IsSymmetric())
   132  
   133  }
   134  
   135  func Test_Matrix_Get(t *testing.T) {
   136  	m := NewFromArrays([][]float64{
   137  		{1, 2, 3},
   138  		{4, 5, 6},
   139  		{7, 8, 9},
   140  	})
   141  
   142  	assert.ItsEqual(t, 1, m.Get(0, 0))
   143  	assert.ItsEqual(t, 2, m.Get(0, 1))
   144  	assert.ItsEqual(t, 3, m.Get(0, 2))
   145  	assert.ItsEqual(t, 4, m.Get(1, 0))
   146  	assert.ItsEqual(t, 5, m.Get(1, 1))
   147  	assert.ItsEqual(t, 6, m.Get(1, 2))
   148  	assert.ItsEqual(t, 7, m.Get(2, 0))
   149  	assert.ItsEqual(t, 8, m.Get(2, 1))
   150  	assert.ItsEqual(t, 9, m.Get(2, 2))
   151  }
   152  
   153  func Test_Matrix_Set(t *testing.T) {
   154  	m := NewFromArrays([][]float64{
   155  		{1, 2, 3},
   156  		{4, 5, 6},
   157  		{7, 8, 9},
   158  	})
   159  
   160  	m.Set(1, 1, 99)
   161  	assert.ItsEqual(t, 99, m.Get(1, 1))
   162  }
   163  
   164  func Test_Matrix_Col(t *testing.T) {
   165  	m := NewFromArrays([][]float64{
   166  		{1, 2, 3},
   167  		{4, 5, 6},
   168  		{7, 8, 9},
   169  	})
   170  
   171  	assert.ItsEqual(t, []float64{1, 4, 7}, m.Col(0))
   172  	assert.ItsEqual(t, []float64{2, 5, 8}, m.Col(1))
   173  	assert.ItsEqual(t, []float64{3, 6, 9}, m.Col(2))
   174  }
   175  
   176  func Test_Matrix_Row(t *testing.T) {
   177  	m := NewFromArrays([][]float64{
   178  		{1, 2, 3},
   179  		{4, 5, 6},
   180  		{7, 8, 9},
   181  	})
   182  
   183  	assert.ItsEqual(t, []float64{1, 2, 3}, m.Row(0))
   184  	assert.ItsEqual(t, []float64{4, 5, 6}, m.Row(1))
   185  	assert.ItsEqual(t, []float64{7, 8, 9}, m.Row(2))
   186  }
   187  
   188  func Test_Matrix_SwapRows(t *testing.T) {
   189  	m := NewFromArrays([][]float64{
   190  		{1, 2, 3},
   191  		{4, 5, 6},
   192  		{7, 8, 9},
   193  	})
   194  
   195  	m.SwapRows(0, 1)
   196  
   197  	assert.ItsEqual(t, []float64{4, 5, 6}, m.Row(0))
   198  	assert.ItsEqual(t, []float64{1, 2, 3}, m.Row(1))
   199  	assert.ItsEqual(t, []float64{7, 8, 9}, m.Row(2))
   200  }
   201  
   202  func Test_Matrix_Copy(t *testing.T) {
   203  	m := NewFromArrays([][]float64{
   204  		{1, 2, 3},
   205  		{4, 5, 6},
   206  		{7, 8, 9},
   207  	})
   208  
   209  	m2 := m.Copy()
   210  	assert.ItsFalse(t, m == m2)
   211  	assert.ItsTrue(t, m.Equals(m2))
   212  }
   213  
   214  func Test_Matrix_DiagonalVector(t *testing.T) {
   215  	m := NewFromArrays([][]float64{
   216  		{1, 4, 7},
   217  		{4, 2, 8},
   218  		{7, 8, 3},
   219  	})
   220  
   221  	diag := m.DiagonalVector()
   222  	assert.ItsEqual(t, []float64{1, 2, 3}, diag)
   223  }
   224  
   225  func Test_Matrix_DiagonalVector_landscape(t *testing.T) {
   226  	m := NewFromArrays([][]float64{
   227  		{1, 4, 7, 99},
   228  		{4, 2, 8, 99},
   229  	})
   230  
   231  	diag := m.DiagonalVector()
   232  	assert.ItsEqual(t, []float64{1, 2}, diag)
   233  }
   234  
   235  func Test_Matrix_DiagonalVector_portrait(t *testing.T) {
   236  	m := NewFromArrays([][]float64{
   237  		{1, 4},
   238  		{4, 2},
   239  		{99, 99},
   240  	})
   241  
   242  	diag := m.DiagonalVector()
   243  	assert.ItsEqual(t, []float64{1, 2}, diag)
   244  }
   245  
   246  func Test_Matrix_Diagonal(t *testing.T) {
   247  	m := NewFromArrays([][]float64{
   248  		{1, 4, 7},
   249  		{4, 2, 8},
   250  		{7, 8, 3},
   251  	})
   252  
   253  	m2 := NewFromArrays([][]float64{
   254  		{1, 0, 0},
   255  		{0, 2, 0},
   256  		{0, 0, 3},
   257  	})
   258  
   259  	assert.ItsTrue(t, m.Diagonal().Equals(m2))
   260  }
   261  
   262  func Test_Matrix_Equals(t *testing.T) {
   263  	m := NewFromArrays([][]float64{
   264  		{1, 4, 7},
   265  		{4, 2, 8},
   266  		{7, 8, 3},
   267  	})
   268  
   269  	assert.ItsFalse(t, m.Equals(nil))
   270  	var nilMatrix *Matrix
   271  	assert.ItsTrue(t, nilMatrix.Equals(nil))
   272  	assert.ItsFalse(t, m.Equals(New(1, 1)))
   273  	assert.ItsFalse(t, m.Equals(New(3, 3)))
   274  	assert.ItsTrue(t, m.Equals(New(3, 3, 1, 4, 7, 4, 2, 8, 7, 8, 3)))
   275  }
   276  
   277  func Test_Matrix_L(t *testing.T) {
   278  	m := NewFromArrays([][]float64{
   279  		{1, 2, 3},
   280  		{4, 5, 6},
   281  		{7, 8, 9},
   282  	})
   283  
   284  	l := m.L()
   285  	assert.ItsTrue(t, l.Equals(New(3, 3, 1, 2, 3, 0, 5, 6, 0, 0, 9)))
   286  }
   287  
   288  func Test_Matrix_U(t *testing.T) {
   289  	m := NewFromArrays([][]float64{
   290  		{1, 2, 3},
   291  		{4, 5, 6},
   292  		{7, 8, 9},
   293  	})
   294  
   295  	u := m.U()
   296  	assert.ItsTrue(t, u.Equals(New(3, 3, 0, 0, 0, 4, 0, 0, 7, 8, 0)))
   297  }
   298  
   299  func Test_Matrix_String(t *testing.T) {
   300  	m := NewFromArrays([][]float64{
   301  		{1, 2, 3},
   302  		{4, 5, 6},
   303  		{7, 8, 9},
   304  	})
   305  
   306  	assert.ItsEqual(t, "1 2 3 \n4 5 6 \n7 8 9 \n", m.String())
   307  }
   308  
   309  func Test_Matrix_LU(t *testing.T) {
   310  	m := NewFromArrays([][]float64{
   311  		{1, 3, 5},
   312  		{2, 4, 7},
   313  		{1, 1, 0},
   314  	})
   315  
   316  	l, u, p := m.LU()
   317  	assert.ItsNotNil(t, l)
   318  	assert.ItsNotNil(t, u)
   319  	assert.ItsNotNil(t, p)
   320  }
   321  
   322  func Test_Matrix_QR(t *testing.T) {
   323  	m := NewFromArrays([][]float64{
   324  		{12, -51, 4},
   325  		{6, 167, -68},
   326  		{-4, 24, -41},
   327  	})
   328  
   329  	q, r := m.QR()
   330  	assert.ItsNotNil(t, q)
   331  	assert.ItsNotNil(t, r)
   332  
   333  	q.WithEpsilon(DefaultEpsilon)
   334  	r.WithEpsilon(DefaultEpsilon)
   335  
   336  	qExpected := NewFromArrays([][]float64{
   337  		{-0.857142857142857, 0.39428571428571413, -0.3314285714285714},
   338  		{-0.4285714285714285, -0.9028571428571427, 0.03428571428571427},
   339  		{0.2857142857142857, -0.17142857142857137, -0.9428571428571428},
   340  	})
   341  
   342  	rExpected := NewFromArrays([][]float64{
   343  		{-14, -21, 14},
   344  		{0, -175, 70},
   345  		{0, 0, 35},
   346  	})
   347  
   348  	assert.ItsTrue(t, q.EqualsEpsilon(qExpected), q.String())
   349  	assert.ItsTrue(t, r.EqualsEpsilon(rExpected), r.String())
   350  }
   351  
   352  func Test_Matrix_Transpose(t *testing.T) {
   353  	m := NewFromArrays([][]float64{
   354  		{1, 2, 3},
   355  		{4, 5, 6},
   356  		{7, 8, 9},
   357  		{10, 11, 12},
   358  	})
   359  
   360  	m2 := m.Transpose()
   361  
   362  	rows, cols := m2.Size()
   363  	assert.ItsEqual(t, 3, rows)
   364  	assert.ItsEqual(t, 4, cols)
   365  
   366  	assert.ItsEqual(t, 1, m2.Get(0, 0))
   367  	assert.ItsEqual(t, 10, m2.Get(0, 3))
   368  	assert.ItsEqual(t, 3, m2.Get(2, 0))
   369  }