Inicializando la matriz de impulso con std :: vector o array

Question

Tengo un método que toma std :: vector como uno de sus parámetros. ¿Hay alguna manera de inicializar una matriz asignando std :: vector a la matriz? Esto es lo que traté de hacer a continuación. ¿Alguien sabe cómo puedo lograr asignar el vector (o incluso un puntero de dobles) a la matriz? Gracias por adelantado. Mike

void Foo(std::vector v) 
{ 
    matrix<double> m(m, n, v); 
    // work with matrix... 
} 

Answer 1

Según la boost matrix documentation, hay 3 constructores de la clase de matriz: vacío, copia, y una toma de dos size_types para el número de filas y columnas. Como el impulso no lo define (probablemente porque hay muchas maneras de hacerlo y no todas las clases tienen que definir una conversión en cualquier otra clase), necesitará definir la conversión.

Este es un enfoque que usaría, pero dado que hay varias maneras de hacerlo y la pregunta no especifica cómo se quiere hacer esto, puede encontrar un enfoque diferente más aplicable a su situación.

void Foo(const std::vector<double> & v) { 
    size_t m = ... // you need to specify 
    size_t n = ... // you need to specify 

    if(v.size() < m * n) { // the vector size has to be bigger or equal than m * n 
     // handle this situation 
    } 

    matrix<double> mat(m, n); 
    for(size_t i=0; i<mat.size1(); i++) { 
     for(size_t j=0; j<mat.size2(); j++) { 
     mat(i,j) = v[i+j*mat.size1()]; 
     } 
    } 
} 

Un par de notas acerca de su código proporcionado: std :: vector necesita un argumento de plantilla y que están declarando m como una matriz y un argumento de entrada a la misma del constructor.

Answer 2

aquí todavía es otro ejemplo de cómo se puede hacer esto:

#include <algorithm> 
#include <vector> 
#include <boost/numeric/ublas/storage.hpp> 
#include <boost/numeric/ublas/matrix.hpp> 
#include <boost/numeric/ublas/io.hpp> 

namespace ublas = boost::numeric::ublas; 

template <typename T, typename F=ublas::row_major> 
ublas::matrix<T, F> makeMatrix(std::size_t m, std::size_t n, const std::vector<T> & v) 
{ 
    if(m*n!=v.size()) { 
     ; // Handle this case 
    } 
    ublas::unbounded_array<T> storage(m*n); 
    std::copy(v.begin(), v.end(), storage.begin()); 
    return ublas::matrix<T>(m, n, storage); 
} 

int main() {; 
    std::vector<double> vec {1, 2, 3, 4, 5, 6}; 
    ublas::matrix<double> mm = makeMatrix(3,2,vec); 
    std::cout << mm << std::endl; 
} 

Answer 3

Una forma más conveniente es así:

matrix<double> m(m*n); 
std::copy(v.begin(), v.end(), m.data().begin());