remplissage d'un coup de pouce vecteur ou d'une matrice

Est-il une seule façon, l'expression d'attribuer un scalaire à tous les éléments d'un coup de pouce de la matrice ou du vecteur? J'essaie de trouver une façon plus compacte de représenter:

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

Suivantes ne fonctionnent pas:

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

boost::numeric::ublas::c_vector<float, N> v;
v = myScalar;
  • Vous devez également appeler cela "C++".
InformationsquelleAutor Mr Fooz | 2009-04-28
  1. 7

    Parce que le vecteur des modèles standard d'accès aléatoire conteneur, vous devriez être en mesure d'utiliser la norme algorithmes de la STL. Quelque chose comme:

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

    ou

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

    Il probablement est également compatible avec les Boost.Attribuer mais vous auriez à vérifier.

    • Les algorithmes de la STL ne semble pas fonctionner. Merci. Coup de pouce.Attribuer ne semble pas fonctionner pour moi, mais je pense que c'est parce que je suis en utilisant un c_vector (const taille du vecteur) au lieu d'un vecteur (dynamiquement la taille du vecteur), de sorte push_back ne fonctionne pas.
    • Ce n'est pas la réponse à la façon dont vous remplissez un boost::numeric::ublas::matrix
    InformationsquelleAutor user21714
  2. 6

    J'ai commencé à utiliser boost::assign pour les cas que je veux affecter de manière statique de valeurs spécifiques (exemples levé à partir du lien ci-dessus).

    #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;
}

    Vous pouvez également utiliser boost::assign pour les cartes.

    #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 );

    Vous pouvez vous permettre de faire l'affectation directe avec list_of() et 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);

}

    Il existe aussi des fonctions pour repeat(), repeat_fun(), et range() qui permet d'ajouter de répéter des valeurs ou des plages de valeurs.

    • Le premier exemple semble être pour le std::vector (pour qui il travaille), pas de boost::numeric::ublas::vector (pour qui ça ne marche pas).
    InformationsquelleAutor chrish
  3. 5

    La manière recommandée ressemble à ceci:

    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);

    La en est de même pour la matrice types:

    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);
    • Comment puis-je obtenir le type de la valeur si je ne sais pas cela?
    InformationsquelleAutor BloodAxe
  4. 1

    Avez-vous essayé ceci?

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

    InformationsquelleAutor dario
  5. 0

    Été un moment depuis que j'ai utilisé le C++. Réalise les travaux suivants?

    for (size_t i = 0; i < N; v[i++] = myScalar) ;
    • Que ça va marcher, même si c'est une déclaration complète, par opposition à une expression.
    • Vrai, mais il est plus compact, qui est ce que tu voulais en se basant sur le post.
    • -1 désolé. Vous devez utiliser "v[i++]" -- "v[++i]" ignorer l'initialisation de la v[0] et d'écraser la mémoire-delà de la fin du vecteur.
    • Accusé de réception. Désolé! Je ne reconnais que j'ai eu à utiliser le bon opérateur unaire, mais pour une raison que je n'arrêtais pas de penser ++i est celui qui s'incrémente i après l'évaluation. Surtout depuis que tout le monde préfère i++ et le "i += 1" comportement semble plus logique. Fixe le moment en tout cas.. Et je suppose que je devrais vous remercier, vous ainsi, j'aime 600 représentant plus de 601!
    InformationsquelleAutor Mikko Rantanen