La moyenne mobile/total de l'algorithme

Qui fonctionne certes, mais vous êtes en train de faire un peu plus de travail que vous avez à. Vous pouvez éviter de déplacer toutes les données autour, et vous pouvez le configurer de sorte que le calcul de la prochaine total est une question de soustraire la valeur la plus ancienne, et l'ajout de la nouvelle valeur.

Par exemple:

//assume that currentIndex is where you want to add the new item
//You have another value, currentTotal, that is initialized at 0.
currentTotal = currentTotal - runningTotal[currentIndex] + d;
runningTotal[currentIndex] = d;
//increment the index.
currentIndex = (currentIndex + 1) % 7;

Il utilise une mémoire tampon circulaire et maintient la currentTotal de sorte qu'il est toujours disponible.

OriginalL'auteur Jim Mischel

Il serait plus facile d'utiliser une liste de tableaux au lieu d'un tableau. Ensuite, vous pouvez simplement utiliser

ArrayList<Double> runningTotal = new ArrayList<Double>();

....

runningTotal.remove(0);
runningTotal.add(d);

OriginalL'auteur mamboking

Pourquoi avez-vous initialiser runningTotal à null? Quel est son type? Où il est déclaré? Il serait bien si vous mettez un peu d'exemples de code qui ressemblent réelle de code Java.

De passer, ma critique serait la suivante: votre fonction n'est de trop. Une fonction ou une méthode, doit être cohérente. De façon plus appropriée, ils doivent faire une chose et une chose seulement.

Pire encore, ce qui se passe dans votre boucle lorsque x = 5? Vous copiez runningTotal[6] en runningTotal[5], mais ensuite vous avez deux copies de la même valeur à la position 5 et 6.

Dans votre conception, votre fonction

1. se déplace/mélange les éléments de votre tableau
2. calcule le total
3. imprime des trucs erreur standard
4. renvoie le total

Il en fait trop.

Ma première suggestion est de ne pas déplacer des choses autour de la matrice. Au lieu de cela, mettre en œuvre un tampon circulaire et de l'utiliser à la place du tableau. Il permettra de simplifier la conception de votre. Ma deuxième suggestion est de briser les choses en fonctions de la cohésion:

1. ont une structure de données (un tampon circulaire) qui vous permet d'ajouter (et que les gouttes de l'entrée la plus ancienne à chaque fois qu'il a atteint sa capacité.)
2. ont la structure de données de mettre en œuvre un interator
3. ont une fonction qui calcule le total sur l'itérateur (vous n'avez pas de soins si vous êtes le calcul du total de sortir d'un tableau, d'une liste ou d'une circulaire bufer.)
4. ne l'appelez pas total. Appeler somme, qui est ce que vous êtes en informatique.

C'est ce que je ferais 🙂

//java pseudocode below - might not compile.

//assume you have a class called CircularBuffer, of say, doubles,
public class CircularBuffer
{
  public CircularBuffer(final int capacity) {...}
  public int getSize(){ ... return # of elements in it ... }
  public add(final Double d){ ... add to the end, drop from the front if we reach capacity... }
  public Iterator<Double> iterator(){ ... gets an interator over the content of the buffer ...}
}

//somewhere else, in another class... NOT ON CircularBuffer

public class Calculator
{
  //assume none of the double values is null
  static public Double sum(final Double ... doubles )
  {
    double sum= 0;
    for( Double d : doubles )
    {
      total += d.doubleValue();
    }
    return sum;
  }

 //you can calculate other things too
 static public Double avg(final Double ... doubles ){...}
 static public Double std(final Double ... doubles ){...}
}

///somewhere else
{
  CircularBuffer buffer = new CircularBuffer(7);

  while( readingAndReadingAndReading )
  {
    //drops oldest values as it reaches capacity
    //always keeping the latest 7 readings
    buffer.add( getLatestValueFromSomewhere() );
  }

  System.out.println( "total=" + Calculator.sum() );
  System.out.println( "average=" + Calculator.avg() );
  System.out.println( "standard deviation=" + Calculator.std() );
}

OriginalL'auteur luis.espinal