転置操作を追加します。

rust/docs/matrix/add.md

@@ -4,7 +4,7 @@
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
 let mut m1: Matrix<i32> = Matrix::new([[1, 2], [3, 4]]);
 let m2: Matrix<i32> = Matrix::new([[5, 6], [7, 8]]);
 m1.add(&m2).unwrap();

rust/docs/matrix/add_assign.md

@@ -4,7 +4,7 @@
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
 let mut m1: Matrix<i32> = Matrix::new([[1, 2], [3, 4]]);
 let m2: Matrix<i32> = Matrix::new([[5, 6], [7, 8]]);
 m1 += m2;

rust/docs/matrix/add_trait.md

@@ -1,15 +1,15 @@
 同じサイズの行列同士の要素ごとの加算を行います。
-* サイズが異なる行列同士の加算はNoneを返します。
+* サイズが異なる行列同士の加算はパニックを引き起こします。
 
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
 let m1: Matrix<i32> = Matrix::new([[1, 2], [3, 4]]);
 let m2: Matrix<i32> = Matrix::new([[5, 6], [7, 8]]);
 let m3 = m1 + m2;
-assert_eq!(m3.unwrap().get(0, 0), Some(&6));
-assert_eq!(m3.unwrap().get(0, 1), Some(&8));
-assert_eq!(m3.unwrap().get(1, 0), Some(&10));
-assert_eq!(m3.unwrap().get(1, 1), Some(&12));
+assert_eq!(m3[(0, 0)], 6);
+assert_eq!(m3[(0, 1)], 8);
+assert_eq!(m3[(1, 0)], 10);
+assert_eq!(m3[(1, 1)], 12);
 ```

rust/docs/matrix/add_with.md

@@ -1,10 +1,11 @@
 同じサイズの行列同士の要素ごとの加算を行います。
-* サイズが異なる行列同士の加算はエラーを返します。
+* サイズが異なる行列同士の加算はパニックを引き起こします。
 
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
+use NeuralNetwork::matrix_algorithm::*;
 let mut m1: Matrix<i32> = Matrix::new([[1, 2], [3, 4]]);
 let m2: Matrix<i32> = Matrix::new([[5, 6], [7, 8]]);
 m1.add_with::<NaiveAlgorithm, _>(&m2).unwrap();

rust/docs/matrix/col_iter.md

@@ -3,7 +3,7 @@
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
 let m: Matrix<i32> = Matrix::with_size(2, 2);
 assert_eq!(m.col_iter(0).unwrap().collect::<Vec<&i32>>(), vec![&0, &0]);
 ```

rust/docs/matrix/col_iter_mut.md

@@ -3,7 +3,7 @@
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
 let mut m: Matrix<i32> = Matrix::with_size(2, 2);
 if let Some(col_iter) = m.col_iter_mut(0) {
    col_iter.for_each(|val| *val = 42);

rust/docs/matrix/col_par_iter.md

@@ -4,10 +4,11 @@
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
+use rayon::prelude::*;
 let mut m: Matrix<i32> = Matrix::with_size(2, 2);
 if let Some(col_iter) = m.col_par_iter_mut(0) {
    col_iter.for_each(|val| *val = 42);
 }
 assert_eq!(m.col_iter(0).unwrap().collect::<Vec<&i32>>(), vec![&42, &42]);
-```
+```

rust/docs/matrix/col_par_iter_mut.md

@@ -4,9 +4,10 @@
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
+use rayon::prelude::*;
 let mut m: Matrix<i32> = Matrix::new([[1, 2], [3, 4]]);
 m.col_par_iter_mut(0).unwrap().for_each(|x| *x *= 2);
 assert_eq!(m[(0, 0)], 2);
 assert_eq!(m[(1, 0)], 6);
-```
+```

rust/docs/matrix/cols.md

@@ -3,7 +3,7 @@
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
 let m: Matrix<i32> = Matrix::with_size(3, 4); // [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
 assert_eq!(m.cols(), 4);
 ```

rust/docs/matrix/div.md

@@ -1,11 +1,11 @@
 同じサイズの行列同士の要素ごとの除算を行います。
-* サイズが異なる行列同士の除算はエラーを返します。
-* 0で割る要素がある場合もエラーを返します。
+* サイズが異なる行列同士の除算はパニックを引き起こします。
+* 0で割る要素がある場合もパニックを引き起こします。
 
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
 let mut m1: Matrix<i32> = Matrix::new([[1, 2], [3, 4]]);
 let m2: Matrix<i32> = Matrix::new([[5, 6], [7, 8]]);
 m1.div(&m2).unwrap();

rust/docs/matrix/div_assign.md

@@ -5,7 +5,7 @@
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
 let mut m1: Matrix<i32> = Matrix::new([[10, 20], [30, 40]]);
 let m2: Matrix<i32> = Matrix::new([[1, 2], [3, 4]]);
 m1 /= m2;

rust/docs/matrix/div_trait.md

@@ -1,15 +1,16 @@
 同じサイズの行列同士の要素ごとの除算を行います。
-* サイズが異なる行列同士の除算はNoneを返します。
-* 0で割る要素がある場合もNoneを返します。
+* サイズが異なる行列同士の除算はパニックを引き起こします。
+* 0で割る要素がある場合もパニックを引き起こします。
 
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
+let m1: Matrix<i32> = Matrix::new([[10, 20], [30, 40]]);
 let m2: Matrix<i32> = Matrix::new([[1, 2], [3, 4]]);
 let m3 = m1 / m2;
-assert_eq!(m3.unwrap().get(0, 0), Some(&10));
-assert_eq!(m3.unwrap().get(0, 1), Some(&10));
-assert_eq!(m3.unwrap().get(1, 0), Some(&10));
-assert_eq!(m3.unwrap().get(1, 1), Some(&10));
+assert_eq!(m3[(0, 0)], 10);
+assert_eq!(m3[(0, 1)], 10);
+assert_eq!(m3[(1, 0)], 10);
+assert_eq!(m3[(1, 1)], 10);
 ```

rust/docs/matrix/div_with.md

@@ -1,16 +1,17 @@
 同じサイズの行列同士の要素ごとの除算を行います。
-* サイズが異なる行列同士の除算はエラーを返します。
-* 0で割る要素がある場合もエラーを返します。
+* サイズが異なる行列同士の除算はパニックを引き起こします。
+* 0で割る要素がある場合もパニックを引き起こします。
 
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
+use NeuralNetwork::matrix_algorithm::*;
 let mut m1: Matrix<i32> = Matrix::new([[1, 2], [3, 4]]);
 let m2: Matrix<i32> = Matrix::new([[5, 6], [7, 8]]);
 m1.div_with::<NaiveAlgorithm, _>(&m2).unwrap();
-assert_eq!(m1.get(0, 0), Some(&0));
-assert_eq!(m1.get(0, 1), Some(&0));
-assert_eq!(m1.get(1, 0), Some(&0));
-assert_eq!(m1.get(1, 1), Some(&0));
+assert_eq!(m1[(0, 0)], 0);
+assert_eq!(m1[(0, 1)], 0);
+assert_eq!(m1[(1, 0)], 0);
+assert_eq!(m1[(1, 1)], 0);
 ```

rust/docs/matrix/get.md

@@ -3,7 +3,7 @@
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
 let m: Matrix<i32> = Matrix::with_size(2, 2);
 assert_eq!(m.get(0, 0), Some(&0));
 ```

rust/docs/matrix/get_mut.md

@@ -3,7 +3,7 @@
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
 let mut m: Matrix<i32> = Matrix::with_size(2, 2);
 if let Some(val) = m.get_mut(0, 0) {
     *val = 42;

rust/docs/matrix/hadamard_mul.md

@@ -4,7 +4,7 @@
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
 let mut m1: Matrix<i32> = Matrix::new([[1, 2], [3, 4]]);
 let m2: Matrix<i32> = Matrix::new([[5, 6], [7, 8]]);
 m1.hadamard_mul(&m2).unwrap();

rust/docs/matrix/hadamard_mul_with.md

@@ -4,12 +4,13 @@
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
+use NeuralNetwork::matrix_algorithm::*;
 let mut m1: Matrix<i32> = Matrix::new([[1, 2], [3, 4]]);
 let m2: Matrix<i32> = Matrix::new([[5, 6], [7, 8]]);
 m1.hadamard_mul_with::<NaiveAlgorithm, _>(&m2).unwrap();
-assert_eq!(m1.get(0, 0), Some(&5));
-assert_eq!(m1.get(0, 1), Some(&12));
-assert_eq!(m1.get(1, 0), Some(&21));
-assert_eq!(m1.get(1, 1), Some(&32));
+assert_eq!(m1[(0, 0)], 5);
+assert_eq!(m1[(0, 1)], 12);
+assert_eq!(m1[(1, 0)], 21);
+assert_eq!(m1[(1, 1)], 32);
 ```

rust/docs/matrix/index.md

@@ -3,10 +3,10 @@
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
 let m: Matrix<i32> = Matrix::new([[1, 2], [3, 4]]);
 assert_eq!(m[(0, 0)], 1);
 assert_eq!(m[(0, 1)], 2);
 assert_eq!(m[(1, 0)], 3);
-assert_eq!(m[(1, 1)], 4]);
+assert_eq!(m[(1, 1)], 4);
 ```

rust/docs/matrix/mul.md

@@ -1,10 +1,10 @@
 行列積を行います。
-* 列数と行数が一致しない行列同士の乗算はエラーを返します。
+* 列数と行数が一致しない行列同士の乗算はパニックを引き起こします。
 
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
 let mut m1: Matrix<i32> = Matrix::new([[1, 2], [3, 4]]);
 let m2: Matrix<i32> = Matrix::new([[5, 6], [7, 8]]);
 m1.mul(&m2).unwrap();

rust/docs/matrix/mul_assign.md

@@ -4,7 +4,7 @@
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
 let mut m1: Matrix<i32> = Matrix::new([[1, 2], [3, 4]]);
 let m2: Matrix<i32> = Matrix::new([[5, 6], [7, 8]]);
 m1 *= m2;

rust/docs/matrix/mul_trait.md

@@ -1,15 +1,15 @@
 同じサイズの行列同士の要素ごとの乗算を行います。
-* サイズが異なる行列同士の乗算はNoneを返します。
+* サイズが異なる行列同士の乗算はパニックを引き起こします。
 
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
 let m1: Matrix<i32> = Matrix::new([[1, 2], [3, 4]]);
 let m2: Matrix<i32> = Matrix::new([[5, 6], [7, 8]]);
 let m3 = m1 * m2;
-assert_eq!(m3.unwrap().get(0, 0), Some(&19));
-assert_eq!(m3.unwrap().get(0, 1), Some(&22));
-assert_eq!(m3.unwrap().get(1, 0), Some(&43));
-assert_eq!(m3.unwrap().get(1, 1), Some(&50));
+assert_eq!(m3[(0, 0)], 19);
+assert_eq!(m3[(0, 1)], 22);
+assert_eq!(m3[(1, 0)], 43);
+assert_eq!(m3[(1, 1)], 50);
 ```

rust/docs/matrix/mul_with.md

@@ -1,10 +1,11 @@
 行列積を行います。
-* 列数と行数が一致しない行列同士の乗算はエラーを返します。
+* 列数と行数が一致しない行列同士の乗算はパニックを引き起こします。
 
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
+use NeuralNetwork::matrix_algorithm::*;
 let mut m1: Matrix<i32> = Matrix::new([[1, 2], [3, 4]]);
 let m2: Matrix<i32> = Matrix::new([[5, 6], [7, 8]]);
 m1.mul_with::<NaiveAlgorithm, _>(&m2).unwrap();

rust/docs/matrix/row_iter.md

@@ -3,7 +3,10 @@
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
 let m: Matrix<i32> = Matrix::with_size(2, 2);
-assert_eq!(m.row_iter(0).unwrap().collect::<Vec<&i32>>(), vec![&0, &0]);
+assert_eq!(
+    m.row_iter(0).unwrap().collect::<Vec<&i32>>(), 
+    vec![&0, &0]
+);
 ```

rust/docs/matrix/row_iter_mut.md

@@ -3,10 +3,13 @@
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
+
 let mut m: Matrix<i32> = Matrix::with_size(2, 2);
-if let Some(row_iter) = m.row_mut_iter(0) {
+if let Some(row_iter) = m.row_iter_mut(0) {
     row_iter.for_each(|val| *val = 42);
 }
-assert_eq!(m.row_mut_iter(0).unwrap().collect::<Vec<&i32>>(), vec![&42, &42]);
+
+assert_eq!(m[(0, 0)], 42);
+assert_eq!(m[(0, 1)], 42);
 ```

rust/docs/matrix/row_par_iter.md

@@ -4,8 +4,9 @@
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
+use rayon::prelude::*;
 let m: Matrix<i32> = Matrix::new([[1, 2], [3, 4]]);
 let sum: i32 = m.row_par_iter(0).unwrap().cloned().sum();
 assert_eq!(sum, 3);
-```
+```

rust/docs/matrix/row_par_iter_mut.md

@@ -4,8 +4,10 @@
 # Examples
 
 ```rust
-use matrix::Matrix;
-let m: Matrix<i32> = Matrix::new([[1, 2], [3, 4]]);
+use NeuralNetwork::matrix::Matrix;
+use rayon::prelude::*;
+
+let mut m: Matrix<i32> = Matrix::new([[1, 2], [3, 4]]);
 m.row_par_iter_mut(0).unwrap().for_each(|x| *x *= 2);
 assert_eq!(m[(0, 0)], 2);
-```
+```

rust/docs/matrix/rows.md

@@ -3,7 +3,7 @@
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
 let m: Matrix<i32> = Matrix::with_size(3, 4); // [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
 assert_eq!(m.rows(), 3);
 ```

rust/docs/matrix/sub.md

@@ -1,10 +1,10 @@
 同じサイズの行列同士の要素ごとの減算を行います。
-* サイズが異なる行列同士の減算はエラーを返します。
+* サイズが異なる行列同士の減算はパニックを引き起こします。
 
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
 let mut m1: Matrix<i32> = Matrix::new([[1, 2], [3, 4]]);
 let m2: Matrix<i32> = Matrix::new([[5, 6], [7, 8]]);
 m1.sub(&m2).unwrap();

rust/docs/matrix/sub_assign.md

@@ -4,7 +4,7 @@
 # Examples
 
 ```rust
-use matrix::Matrix;
+use NeuralNetwork::matrix::Matrix;
 let mut m1: Matrix<i32> = Matrix::new([[1, 2], [3, 4]]);
 let m2: Matrix<i32> = Matrix::new([[5, 6], [7, 8]]);
 m1 -= m2;