Comportements de réduction

Les comportements de réduction suivants peuvent être utilisés :

Accumulate_Rolling

Calcule la réduction sur une fenêtre en mouvement.

Syntaxe :

  • result = Accumulate_Rolling_<reduction function>(input, range)

Arguments :

  • Résultat T : la fonction de réduction appliquée à la plage donnée
  • Entrée T : le signal à réduire
  • Double plage : une séquence de plages

Remarque : T peut être n'importe quel type pris en charge par la fonction de réduction donnée.

Accumulate_Rolling(input, windowStart)

Le comportement "Accumulate_Rolling" applique la fonction de réduction à une fenêtre en mouvement. Le signal "windowStart" spécifie une fenêtre (voir Plages). Pour chaque plage, les échantillons qui s'étendent sur la plage du signal d'entrée sont réduits conformément à la fonction de réduction et produisent un échantillon de sortie ayant le même horodatage que la fin de la plage.

Exemples :

  • Moyenne mobile sur les 2 dernières secondes :

    Accumulate_Rolling_Average(input, Master()-2)

  • Moyenne mobile sur les 10 dernières échantillons :

    Accumulate_Rolling_Average(input, State_Delay(Master(), 0, 10))

Remarques :

  • L'utilisation de la mémoire du comportement "Accumulate rolling" augmente avec le nombre d'échantillons présents dans la fenêtre. Il est possible d'utiliser windowStart = 0, cependant, chaque nouvel échantillon augmentera la mémoire. Selon le signal d'entrée, cela peut conduire à l'utilisation d'une grande quantité de mémoire.

  • Pour un fonctionnement correct, les heures de début des plages doivent être augmentées de façon monotone.

Window_Signal

Calcule une fenêtre avec une « taille » donnée.

Syntaxe :

  • Window_Signal_<reduction function>(input, limit)

Arguments :

  • Double résultat : plages d'entrée ayant la taille donnée de la limite
  • Entrée T : le signal d'entrée qui est réduit pour déterminer la taille d'une fenêtre
  • Limite T : « taille » souhaitée des plages calculées

Remarque : T peut être n'importe quel type pris en charge par la fonction de réduction donnée.

Window_Signal(input, limit)

Le comportement "Window_Signal" calcule pour chaque échantillon d'entrée une plage se terminant à cet échantillon. La taille et donc le début de la plage sont choisis de telle sorte qu'en appliquant la fonction de réduction aux valeurs de l'entrée dans cette plage, la réduction soit approximativement égale à la limite. Plus précisément, l'intervalle le plus petit est choisi lorsque la réduction est supérieure ou égale à la limite.

À titre d'exemple, nous pouvons appliquer la fonction "Accumulate_Rolling" au résultat pour voir les valeurs réelles accumulées pour la fenêtre.

result = Accumulate_Rolling_<function>(input, Window_Signal_<function>(input, limit))

Le résultat sera supérieur ou égal à la limite sauf au début du signal, lorsqu'il n'y a pas encore assez d'échantillons.

Exemple :

  • Créer une fenêtre mobile contenant toujours au moins 80 grammes d'émission de CO2 :

    movingWindow = Window_Signal_Integral(CO2, 80)

    La fenêtre "movingWindow" peut à présent être utilisée pour évaluer d'autres signaux normalisés relatifs à l'émission de CO2.

Accumulate_Prefix

Calcule la réduction d'un signal donné, du départ à l'échantillon actuel.

Syntaxe :

  • result = Accumulate_Prefix_<reduction_function>(input)

Arguments :

  • Résultat T : la réduction d'un signal, du départ à l'échantillon actuel
  • Entrée T : le signal à réduire

Remarque : T peut être n'importe quel type pris en charge par la fonction de réduction donnée.

Le comportement de réduction "Accumulate_Prefix" accumule les échantillons d'entrée avec la fonction de réduction donnée. Le résultat est un signal avec tous les résultats intermédiaires, c'est- à- dire result[i] = reduce(signal[1], …, signal[i]).

Remarque : result = Accumulate_Rolling(signal, -l'infini) sauf que l'utilisation de la mémoire est constante.

Accumulate_Reset

Calcule la réduction d'un signal donné de la dernière réinitialisation à l'échantillon actuel.

Syntaxe :

  • result = Accumulate_Reset_<reduction_function>(input, reset)

Arguments :

  • Résultat T : la réduction du signal depuis la dernière réinitialisation
  • Entrée T : le signal à réduire
  • Réinitialisation Bool : la réduction est redémarrée si c'est vrai

Remarque : T peut être n'importe quel type pris en charge par la fonction de réduction donnée.

Le comportement de réduction "Accumulate_Reset" accumule les échantillons d'entrée avec la fonction de réduction donnée. La réduction est redémarrée lorsque l'entrée de réinitialisation est vraie. Le résultat est un signal avec tous les résultats intermédiaires, c'est- à- dire result[i] = reduce(signal[k], …, signal[i]) où k est l'indice si la dernière réinitialisation était vraie, ou 1 si elle n'a jamais été vraie.

Exemple : Accumulate_Reset_Maximum

Signal

Réinitialisation

Résultat

1

Faux

1

5

Faux

5

3

Faux

5

2

Vrai

2

Accumulate_Samples

Calcule une réduction "Rolling" sur un nombre donné d'échantillons.

Syntaxe :

  • result = Accumulate_Samples_<reduction_function>(input, count)

Arguments :

  • Résultat T : la réduction par rapport au dernier nombre d'échantillons

  • Entrée T : le signal à réduire

  • const int count : le nombre d'échantillons à réduire

Remarque : T peut être n'importe quel type pris en charge par la fonction de réduction donnée.

La fonction "Accumulate_Samples" calcule la réduction par rapport au dernier nombre d'échantillons et à l'échantillon actuel. Au début, lorsque la valeur est inférieure au nombre d'échantillons, tous les échantillons disponibles sont réduits.

Remarque : Accumulate_RollingSample<R>(input, count) = Accumulate_Rolling<R>(input, State_Delay(Master(), -Infinity, count))