Function AddMatrixToPython

kratos/python/add_matrix_to_python.cpp:68–226

    }

    void  AddMatrixToPython(pybind11::module& m)
    {
        //here we add the dense matrix
        auto matrix_binder = CreateMatrixInterface< DenseMatrix<double> >(m,"Matrix");
        matrix_binder.def(py::init<const DenseMatrix<double>::size_type, const DenseMatrix<double>::size_type>());
        matrix_binder.def(py::init( [](py::buffer b){
          py::buffer_info info = b.request();
          KRATOS_ERROR_IF( info.format != py::format_descriptor<double>::value ) << "Expected a double array\n";
          KRATOS_ERROR_IF( info.ndim != 2 ) << "Buffer dimension of 2 is required, got: " << info.ndim << std::endl;
          DenseMatrix<double> matrix = DenseMatrix<double>(info.shape[0], info.shape[1]);
          std::array<std::size_t,2> strides {info.strides[0] / static_cast<std::size_t>(info.itemsize),
                                             info.strides[1] / static_cast<std::size_t>(info.itemsize)};

          for( int i=0; i<info.shape[0]; ++i ) {
            for( int j=0; j<info.shape[1]; ++j ) {
              matrix(i,j) = static_cast<double *>(info.ptr)[i * strides[0] + j * strides[1]];
            }
          }

          return matrix;
        }));

        matrix_binder.def(py::init([](const py::list& input){
          std::size_t num_rows = input.size();
          if( num_rows == 0 || ( (num_rows == 1) && (py::len(input[0]) == 0) ) )
            return DenseMatrix<double>(0,0);
          else{
            std::size_t num_cols = py::len(input[0]);
            DenseMatrix<double>matrix = DenseMatrix<double>(num_rows, num_cols);
            for(std::size_t i = 0; i < num_rows; i++){
              const auto row = py::cast<py::list>(input[i]);
              KRATOS_ERROR_IF( py::len(row) != num_cols ) << "Wrong size of a row " << i << "! Expected " << num_cols << ", got " << py::len(row) << std::endl;;
              for(std::size_t j = 0; j < num_cols; j++){
                  matrix(i,j) = py::cast<double>(row[j]);
              }
            }
            return matrix;
          }
        }));

        matrix_binder.def(py::init<const DenseMatrix<double>::size_type, const DenseMatrix<double>::size_type, const DenseMatrix<double>::value_type >());
        matrix_binder.def("fill", [](DenseMatrix<double>& self, const typename DenseMatrix<double>::value_type value) { noalias(self) = DenseMatrix<double>(self.size1(),self.size2(),value); });
        matrix_binder.def("fill_identity", [](DenseMatrix<double>& self) { noalias(self) = IdentityMatrix(self.size1()); });
        matrix_binder.def("transpose", [](DenseMatrix<double>& self) { return Matrix(trans(self)); });
        matrix_binder.def(py::init<const DenseMatrix<double>& >());
        matrix_binder.def("__mul__", [](const DenseMatrix<double>& m1, const Vector& v){ return Vector(prod(m1,v));}, py::is_operator());
        matrix_binder.def("__mul__", [](const DenseMatrix<double>& m1, const array_1d<double,3>& v){ if(m1.size2() != 3) KRATOS_ERROR << "matrix size2 is not 3!" << std::endl; return Vector(prod(m1,v));}, py::is_operator());
        matrix_binder.def_buffer( [](DenseMatrix<double>& self)-> py::buffer_info{
                                                                    return py::buffer_info(
                                                                    self.data().begin(),
                                                                    sizeof(double),
                                                                    py::format_descriptor<double>::format(),
                                                                    2,
                                                                    {self.size1(),self.size2()},
                                                                    {sizeof(double)*self.size2(),
                                                                     sizeof(double) }
                                                                    );
                                                                    });