Matris Sınıfı

3 Boyutlu Matris
Şöyle yaparız. Koordinatlardan belleğe, bellekten koordinatlara erişim imkanı verir.

template<class T>
class Matrix3D // minimal
{
public:
    using value_type = T;
    using iterator   = std::vector<value_type>::iterator;

private:
    std::vector<value_type> _data;
    size_t _sizex, _sizey, _sizez;

    size_t index_from_coords(size_t x, size_t y, size_t z) const
    {
        return x*_sizex*_sizey + y*_sizey + z;
    }
    std::tuple<size_t, size_t, size_t> coords_from_index(size_t index) const
    {
        const size_t x = index / (_sizex * _sizey);
        index = index % x;
        const size_t y = index / _sizey;
        const size_t z = index % _sizey;
        return make_tuple(x, y, z);
    }
public:
    Matrix3D(size_t sizex, sizey, sizez) : _sizex(sizex), ... {}
    T& operator()(size_t x, size_t y, size_t z) // add const version
    {
        return _data[index_from_coords(x, y, z)];
    }
    std::tuple<size_t, size_t, size_t> coords(iterator it)
    {
        size_t index = std::distance(begin(_data), it);
        return coords_from_index(index);
    }
    iterator begin() { return begin(_data); }
    iterator end()   { return end(_data);   }
}

Şöyle yaparız.

Matrix3D<double> m(3, 3, 3);
auto it = std::max_element(m.begin(), m.end()); 
auto coords = m.coords(it);
std::cout << "x=" << coords.get<0>() << ... << "\n";

Çarpım

Elimizde şöyle bir kod olsun

// dimensions
int m = 4;
int n = 5;
int p = 3;

// 'a' is an 'm×n' matrix
int[][] a = {
        {2, 4, -1, 7, 9},
        {-2, -6, 6, 4, 3},
        {3, 8, 2, 7, -5},
        {8, 5, 3, 2, -7}};

// 'b' is an 'n×p' matrix
int[][] b = {
        {3, -2, 1},
        {8, 0, -9},
        {2, 5, 7},
        {-1, 6, 9},
        {3, -3, 5}};

Şöyle yaparız. İki tane iç içe döngü kurmak yerine IntSream kullanılıyor.

// 'c' is an 'm×p' matrix
int[][] c = IntStream.range(0, m)
        .mapToObj(i -> IntStream.range(0, p)
                .map(j -> IntStream.range(0, n)
                        // multiply the entries
                        // of the i-th row of 'a'
                        // and the j-th column of 'b'
                        .map(k -> a[i][k] * b[k][j])
                        // the sum of the products
                        .sum())
                .toArray())
        .toArray(int[][]::new);

Tersçapraz (Transpose)
- Satırları sütun haline getirmek veya

- Sütunları yukarıdan aşağıya dolaşarak her elemanı yeni bir satıra eklemek 

anlamına gelir.

Örnek
Şöyle yaparız

std::vector<double> transpose_vector(const std::vector<std::vector<double>> &column_vec){
  std::vector<double> row_vector;
  row_vector.reserve(total_entries(column_vec)); // Pre-allocate the space we need

  for (auto c : column_vec) {
    for (auto r : c) {
      row_vector.push_back(r);
    }
  }
  return row_vector;
}

Örnek
Şöyle yaparız.

public class Matrix
{

  private double[][] A;// 2-D array to hold matrix element
  private m,n ; // number of column and row.
 
  public Matrix transpose () {
    Matrix X = new Matrix(n,m);
    double[][] C = X.getArray();
    for (int i = 0; i < m; i++) {
      for (int j = 0; j < n; j++) {
        C[j][i] = A[i][j];
      }
    }
    return X; 
                
  }

  public double[][] getArray () {
    return A;
  }       

}

Aslında 3 tane liste var ve bunların zip()'i alıyoruz diye düşünülebilir.