Comment faire pour incrémenter d'une boucle for avec une valeur décimale en C

J'ai ce code

for (k=0; k<BUFFER_LEN; k++){                

           buffer[k] = sin(2*pi*f/fs*k);          //sine generation

ma boucle incrémente de 1 à chaque fois - si k sera 1, 2, 3, 4, 5.... etc pour chaque calcul

Je voudrais la boucle de l'incrément de 0,1 à chaque fois, par exemple, de sorte que mes sinus de calcul est plus précis?
Quel serait le moyen le plus simple pour y parvenir? J'ai essayé de l'incrémentation de 0,1 en ce que pour la boucle, mais ne pense pas que cela est permis, car le programme fois sur

edit: voici une solution

int i, k;
float z=0.1;

for(i = 0; i < BUFFER_LEN; i++){                         //fill the buffer
       buffer[k] = sin(2*pi*f/fs*z);                     //sine wave value generation
       z = z + 0.1;
       }
Êtes-vous en incrémentant un int par .1 ajoutant .1 vais juste vous obtenir de nouveau le même nombre en raison de la troncature? Il serait plus utile si vous avez fourni une SSCCE.
cette question a besoin d'un peu plus d'informations sur ce que vous aimeriez avoir en buffer, puis à la fin de la boucle.

OriginalL'auteur user2459764 | 2013-08-11

  1. 3

    Solution Simple: Multiples par votre gain désiré

    double gain = 0.1;
for (k=0; k<BUFFER_LEN; k++) {                
  buffer[k] = sin(gain * 2*pi*(f/fs)*k);          //sine generation
}

    Pas besoin de changer votre k de la boucle, BUFFER_LEN & pas de virgule flottante questions. 1/Gain n'a pas besoin d'être un nombre entier.

    D'origine de votre problème est probablement dû à:

    int k;
for (k=0; k<BUFFER_LEN; k += 0.1) {                
  buffer[k] = sin(2*pi*f/fs*k);          //sine generation
}

    Dans ce cas, le k += 0.1 ne k = (int) (k + 0.1) qui tronque la somme de retour pour le k d'origine. Ainsi, la boucle s'exécute jamais.

    Yep! tellement simple que je ne l'aurais cru de cette me - oui, votre droit, si j'ai essayé d'augmenter avec un non-entier la boucle juste couru pour toujours - merci beaucoup!!

    OriginalL'auteur chux

  2. 5

    Si tout ce que vous voulez faire est d'incrément par .1, votre k valeur doit être une constante. Après, c'est aussi simple que cela:

    for(double k = 0; k < limit; k += 0.1)

    Mais le cours de l'utilisation de valeurs décimales pourrait provoquer des erreurs d'arrondi, et votre code doit k un nombre entier. Ici est peut-être une meilleure solution:

    for(int k = 0; k < limit * 10; k++){
    //Now, in your equation, use k/10.0
    buffer[k] = sin(2 * pi * f / fs * (k / 10.0));
}

    Assurez-vous que la taille de buffer est dix fois ce qu'il devrait être!

    vous devriez probablement supprimer la double option, comme le tableau tampon ne peut pas être indexé par elle

    OriginalL'auteur BrainSteel

  3. 0

    Un naïf solution serait:

    for (double k=0; k<BUFFER_LEN/10; k+=0.1){                

           buffer[10*k] = sin(2*pi*f/fs*k);

    Mais les erreurs d'arrondi pourrait conduire à un mauvais résultat. C'est pourquoi vous devez utiliser l'arithmétique des nombres entiers dans la boucle et de se multiplier dans la boucle de 0,1.

    Je vais laisser cela comme un rappel à ne pas faire.

    Si k est égal par exemple 1.1, ce qui ne buffer[1.1] veux dire?
    vrai, corrigé.
    Devrait BUFFER_LEN être un nombre entier (d'une présence probable), BUFFER_LEN/10 va effectuer la division entière. Exemple for (float k=0; k<4/10; k+=0.1) réitérera 0 fois plutôt que 4.
    En raison des erreurs d'arrondi, l'aide à virgule flottante en une itération de boucle, que ce code n'est, peut dépasser le point culminant et aura de plus en plus les erreurs d'arrondi lors de la boucle. Itération de comptage doit être fait avec l'arithmétique des nombres entiers.
    merci. Très vrai. Ne pense pas que.

    OriginalL'auteur Burkhard