rellenando un vector o matriz de impulso

Question

¿Existe una forma de expresión única para asignar un escalar a todos los elementos de una matriz o vector de impulso? Estoy tratando de encontrar una forma más compacta de representar:

boost::numeric::ublas::c_vector<float, N> v; 
for (size_t i=0; i<N; i++) { 
    v[i] = myScalar; 
} 

La siguiente no funcionan:

boost::numeric::ublas::c_vector<float, N> 
    v(myScalar, myScalar, ...and so on..., myScalar); 

boost::numeric::ublas::c_vector<float, N> v; 
v = myScalar; 

Answer 1

Como el vector modela un contenedor de acceso aleatorio estándar, debe poder utilizar los algoritmos estándar de STL. Algo así como:

c_vector<float,N> vec; 
std::fill_n(vec.begin(),N,0.0f); 

o

std::fill(vec.begin(),vec.end(),0.0f); 

Probablemente también es compatible con Boost.Assign pero usted tiene que comprobar.

Answer 2

ha pasado un tiempo desde que utiliza C++. ¿Funciona lo siguiente?

for (size_t i = 0; i < N; v[i++] = myScalar) ; 

Answer 3

He comenzado a usar boost::assign para casos en los que quiero asignar valores específicos estáticamente (ejemplos eliminados del enlace anterior).

#include <boost/assign/std/vector.hpp> 
using namespace boost::assign; // bring 'operator+()' into scope 

{ 
    vector<int> values; 
    values += 1,2,3,4,5,6,7,8,9; 
} 

También puede usar boost::assign para mapas.

#include <boost/assign/list_inserter.hpp> 
#include <string> 
using boost::assign; 

std::map<std::string, int> months; 
insert(months) 
     ("january", 31)("february", 28) 
     ("march",  31)("april", 30) 
     ("may",  31)("june",  30) 
     ("july",  31)("august", 31) 
     ("september", 30)("october", 31) 
     ("november", 30)("december", 31); 

Puede permitir hacer la asignación directa con list_of() y map_list_of()

#include <boost/assign/list_of.hpp> // for 'list_of()' 
#include <list> 
#include <stack> 
#include <string> 
#include <map> 
using namespace std; 
using namespace boost::assign; // bring 'list_of()' into scope 

{ 
    const list<int> primes = list_of(2)(3)(5)(7)(11); 
    const stack<string> names = list_of("Mr. Foo")("Mr. Bar") 
             ("Mrs. FooBar").to_adapter(); 

    map<int,int> next = map_list_of(1,2)(2,3)(3,4)(4,5)(5,6); 

    // or we can use 'list_of()' by specifying what type 
    // the list consists of 
    next = list_of< pair<int,int> >(6,7)(7,8)(8,9); 

} 

También hay funciones para repeat(), repeat_fun() y range() que le permite agregar valores o rangos de valores que se repiten.

Answer 4

¿Has probado esto?

ublas :: c_vector v = ublas :: scalar_vector (N, myScalar);

Answer 5

La forma recomendada es así:

boost::numeric::ublas::c_vector<float, N> v; 
v = boost::numeric::ublas::zero_vector<float>(N); 
v = boost::numeric::ublas::scalar_vector<float>(N, value); 

Lo mismo es para este tipo de matriz:

boost::numeric::ublas::matrix<float> m(4,4); 
m = boost::numeric::ublas::identity_matrix<float>(4,4); 
m = boost::numeric::ublas::scalar_matrix<float>(4,4); 
m = boost::numeric::ublas::zero_matrix<float>(4,4);