Archives par mot-clé : expression lambda

exemple d’expression lambda en csharp: tableau de notes musicales

utiliser l’expression lambda en csharp exemple tableau de notes musicales

Par Ettougourti Mohamed Ali

Le deuxième exemple en csharp que nous proposons en illustration de l’utilisation de l’expression lambda pour les tableaux est un exemple d’un tableau de..Notes musicales.
Commençons par créer une structure spéciale pour la note musicale.
Cette dernière se caractérise par son nom (nom italien do, ré, mi, fa, sol, la, si ) ou anglo-saxon (c, d, e, f, g, a, b).

Elle se caractérise aussi par sa hauteur ou la gamme à laquelle elle appartient selon la norme midi il y a presque 10 gammes. Les valeurs midi vont en effet de 0 pour un do très bas à un sol strident de 127 chaque gamme contenant 12 notes différentes.
Une note musicale se caractérise aussi par sa durée et sa vélocité c’est-à-dire la force avec laquelle elle est jouée.

Elle se caractérise aussi par sa fréquence. Une musique utilisant le quart de note exige une meilleure acuité quant à la fréquence              « exacte » de la note.
Pour faire simple nous allons nous limiter à quelques caractéristiques soit

-la valeur midi de la note,

sa durée,

et sa vélocité.
Traduit en code notre structure peut se présenter de la façon suivante:
public struct note
{

public int val_midi;

public int duree;
public int velocity;

}
Pour remplir notre tableau de nouvelles données nous recourons au générateur de nombres aléatoires fournit par le csharp Random.
Nous voulons que les durées restent entre 1 pour la ronde et 64 pour la plus courte soit quadruple croche,  pour les notes nous voulons qu’elles soient entre 41 pour un fa basse et 62 pour le ré, quant à la vélocité elle est de zéro pour les silences et 127 pour les plus fortes, nous choisissons une rangée entre 0 et 80.
Pour éviter de générer des durées bizarres ne correspondant pas à la nature des durées musicales nous initialisons un tableau de durées acceptables qu’on nommera d
int []d= { 1, 2, 4, 8, 16, 32, 64 };
En évitant les notes pointées.
Nous pouvons forcer le générateur de nombres aléatoires à fournir des valeurs dans les rangées demandées grâce à la fonction next du générateur.
L’initialisation de notre tableau de notes musicales peut se faire en écrivant une seule ligne de code grâce au recours à l’expression lambda.
int [] d= { 1, 2, 3, 4, 8, 16, 32, 64 };

Random t = new Random(0);
note[] n = new note[150];
n =  n.Select(b => b = new note
( t.Next (48, 60) ,
d [ t.Next (1, 7) ] ,
t.Next (0, 80) ) ).ToArray() ;

Une fois le tableau rempli l’expression lambda nous servira pour inspecter, trier, changer les notes musicales.
Nous pouvons commencer par exemple par connaitre la durée de la musique générée en supposant le tempo à 60 noires par minute 

La ligne de code suivante nous permet de le faire
double  totalduree =
n.Where(b => b.duree == 1).Count() * 4 + // pour une ronde comptant 4 noires

n.Where(b => b.duree == 2).Count() * 2 + / pour une blanche comptant 4 noires
n.Where(b => b.duree == 4).Count() * 1 + / /pour une noire 

//pour les divisions de la noire 
n.Where(b => b.duree == 8).Count() * 0.5 +  
n.Where(b => b.duree == 16).Count() * 0.25 +
n.Where(b => b.duree == 32).Count() * 0.125 +
n.Where(b => b.duree == 3).Count() * 64 + 0.0625;
Le total  récupéré dans la variable double  totalduree est divisé par 60 pour trouver la durée en minutes nécessaire à un instrument pour exécuter le morceau musical généré tout à fait de façon aléatoire.
Nous pouvons aussi envisager de deviner le mode du morceau musical généré en comptant l’occurrence des différentes notes et les intervalles dominants entre elles.
Pour ce faire nous allons utiliser deux expressions lambda imbriquées qui en une seule fois vont nous permettre de compter le nombre d’occurrences des différentes notes du morceau musical résultat que nous nous empressons de sauvegarder dans un tableau crée ad hoc.

int [] g = new int [12];

g= g.Select ( (b1 , next ) => b1 = n.Where (b => b.val_midi  %  12 == next ).Count () ).ToArray ();

Le tableau g est créé pour recevoir le nombre d’occurrences des  12 notes musicales naturelles ou altérées.
Ce même tableau est utilisé à l’aide de la variable « next » afin de trouver en utilisant l’instruction « where » les notes dont la valeur midi modulo 12 est égale à « next » et d’en compter les occurrences.
Je ne sais pas quel genre de musique jouera pour vous le morceau de code qu’on vient d’écrire pour moi je trouve que la note dominante est fa# ou f#, que le « la »  bémol ou « a » bémol et le          « si  » ou « b » bémol suivent en importance ce qui laisse deviner un morceau en fa dièse major !!
Et pourquoi ne pas écouter la musique générée pour joindre l’utile à l’agréable ?
A vous d’apprécier la musique.

lambda.mid

lambda.mid (136 téléchargements)

(102)

l’expression lambda dans le c# : passer à la vitesse supérieure

l’expression lambda en c#: passer à la vitesse supérieure :

vous seriez bien étonnés d’apprendre que nous n’avons fait dans nos précédents article qu’effleurer les différents aspects de l’utilisation de l’expression lambda avec les vecteurs et les tableaux

l’utilisation « normale »  concerne les différents tableaux et vecteurs de type conventionnel bien connu.

Que faire si nous projetons d’utiliser des vecteurs d’un type bien particulier. Un vecteur de classe ou de structure définies par nos soins ?

Deux exemples : le premier  traite d’vecteur de fractions , le deuxième se rapporte à un vecteur de notes musicales dont la structure a été définie par nos soins.

Commençons par le premier exemple en créant ensemble une classe spéciale qui porte le nom de « fraction »

Class fraction  { } ;

Pour que la classe soit visible de partout nous la qualifions de publique.

Public class fraction {} ;

Deux constructeurs sont prévus pour initialiser la classe :

Public fraction (int d) ;

Et

Public fraction (int n, int d) ;

Le premier constructeur présume le numérateur de la fraction égal à 1. L’instruction

New fraction (2) ;

Nous donne donc une fraction d’un demi 1/2..

Le deuxième constructeur plus explicite exige d’indiquer et le numérateur et dénominateur. L’instruction

New fraction (2,4) ;

Nous donne une fraction de deux quarts 2/4 soit toujours la moitié.

Voici tout le code concocté.

public class fraction  

        {

    public int num;

            public int den;

 

          public  fraction (int d)

            {

                this.num = 1;

                this.den = d;

            }

           public fraction (int n, int d)

            {

                this.num = n;

                this.den = d;

            }

         }

Nous proposons ensuite de créer un tableau ou un vecteur de fractions qu’on nommera simplement x.

Fraction x= new fraction [5] ;

Initialisons le tableau avec une suite de fractions

            x[0] = new fraction(1, 10);

            x[1] = new fraction(1, 4);

            x[2] = new fraction(1, 24);

            x[3] = new fraction(1, 10);

            x[4] = new fraction(1, 5);

le défi que nous devons relever est celui d’utiliser l’expression lambda pour traiter des données du vecteur x. trouver par exemple la maximale, la minimale, leurs positions respectives ?

L’instruction crue

fraction max = x.Max();

Entraîne une erreur du compilateur attirant notre attention sur le fait que la classe fraction ne contient aucune méthode CompareTo() qui autoriserait la comparaison entre les différents éléments du vecteur. Méthode nécessaire et suffisante pour trouver la valeur maximale et éventuellement la valeur minimale.

Inutile d’insister. le compilateur tenant bon à sa méthode CompareTo force pour nous d’obtempérer.

Nous reprenons donc notre code écrit pour   la classe « fraction » en déclarant la classe base IComparable.

public class fraction  : IComparable

et en y ajoutant la fameuse méthode CompareTo.

int CompareTo (object obj)

            {

                fraction f = (fraction)obj;

                int n = f.num * den;

                int d = f.den * den;

                int n2 = num * f.den;

                int d2 = den * f.den;

                if(n == n2 )return 0;

                else if (n2 > n) return 1;

                return -1;

    }

La méthode CompareTo commence par calculer le dénominateur commun entre les deux fractions.

Si les deux numérateurs sont égaux notre méthode retourne   zéro pour dire que les deux fractions sont égales si n2 est supérieure à n la méthode retourne 1 sinon elle retourne -1 ;

Notre classe fraction réécrite ressemble maintenant au code suivant :

public class fraction  : IComparable

        {

             public int num;

            public int den;

 

          public  fraction (int d)

            {

                this.num = 1;

                this.den = d;

            }

 

           public fraction (int n, int d)

            {

                this.num = n;

                this.den = d;

            }

       public  int CompareTo (object obj)

            {

                fraction f = (fraction)obj;

                int n = f.num * den;

                int d = f.den * den;

                int n2 = num * f.den;

                int d2 = den * f.den;

                if(n == n2 )return 0;

                else if (n2 > n) return 1;

                 return -1;

  }

}

Désormais nous pouvons sans craindre les foudres du compilateur chercher la plus grande valeur du vecteur x.

Fraction max= x.Max() ;

Ou

fraction max = x.Max(b=> b);

max prend la valeur de 1/4 ;

L’instruction

Fraction min= x.Min() ;

Ou encore

fraction min = x.Min(b=> b);

Nous renvoie 1/24 ;

Pour trier le vecteur de fractions de la plus petite à la plus grande, tri dit ascendant, nous pouvons toujours utiliser l’expression lambda avec l’instruction linq orderby

x = x.OrderBy(b=> b).ToArray ();

le vecteur x est désormais ordonné comme suit

1/24, 1/10 , 1/10 , 1/5, 1/4

L’instruction

x = x.OrderByDescending(b => b).ToArray();

Opère un tri dit descendant.

L’instruction reverse est tout aussi opérationnelle.

x = x.Reverse().ToArray();

  L’instruction indexof déjà rencontrée marche tout aussi bien.

 int pos = x.ToList().IndexOf(max);

 pos = x.ToList().IndexOf(min);

 

 

 

 

 

 

 

(54)

utilisation de l’instruction lambda c# 3

utilisation de l’instruction lambda en  c#
par Ettougourti Mohamed Ali

Notre étude de l’utilisation de l’expression lambda dans le c sharp se poursuit.

Poussés par une curiosité que les nécessités de  programmation justifient nous pouvons nous demander si le vecteur objet de notre attention comporte une seule et unique valeur qui se perpétue tout au long du vecteur aussi long et aussi volumineux soit-il.

L’expression lambda nous est là aussi d’un bon secours puisque nous pouvons utiliser l’interrogation « All » pour savoir si toutes les valeurs d’un vecteur sont identiques.

L’instruction « all » renvoie une valeur de type booléen « oui » ou « non » , «  true » ou « false » , vrai ou faux.

Ainsi pour revenir à notre vecteur k de type int initié dans le précédent article nous pouvons l’interroger pour voir si toutes les valeurs du vecteur sont égales à zéro.

int[] k = { 2, 1, 2, 3, 5, 3, 4, 1, 6, 7, 8, 2, 1, 0, 8 };

bool vrai =  k.All (b => b == 0);

l’instruction nous renvoie faux. Ce qui est vrai puisque certaines valeurs du vecteur k sont différentes de 0.

On peut poser la question d’une autre façon et voir si toutes les valeurs sont supérieures à 0.

vrai = k.All(b => b > 0);

la réponse est toujours négative puisque nous savons d’un simple coup d’œil au vecteur k qu’une valeur au moins est égale à zéro.

Excédés nous voulons en finir en posant directement et franchement la question : existe-t-il une seule valeur dans le vecteur qui soit égale à zéro ?

C’est l’instruction Any qui vient à notre secours, satisfait notre curiosité

vrai = k.Any (b => b == 0);

cette fois « vrai » est bien vraie  et la réponse est positive.

D’aucuns proposeraient de se rassurer de l’existence d’une valeur égale à zéro dans notre vecteur k on se prenant autrement mais toujours en recourant aux services précieux de notre expression lambda.

Il est vrai que le c sharp nous offre pour les vecteurs ou les tableaux une autre instruction qui semble à priori remplir les mêmes taches.

L’instruction « first », puisque c’est d’elle dont il s’agit, nous permettrait de vérifier l’existence d’une valeur dans un vecteur.

int[] k = { 2, 1, 2, 3, 5, 3, 4, 1, 6, 7, 8, 2, 1, 0, 8 };

int occ = k.First (b=> b == 3);

s’Il est vrai que l’instruction first employant l’expression lambda nous confirme dans notre intuition de l’existence d’une valeur égale à 3 appartenant au vecteur l’instruction se contente toutefois de renvoyer tout bêtement la valeur recherchée.

En inspectant la variable « occ » on « découvre » sans surprise qu’elle est égale à 3. Ce que nous savons déjà. Merci quand même.

L’instruction « first » semble donc inutile d’autant plus qu’en vérifiant on découvre que l’instruction a vraiment un très mauvais caractère. A vous d’en juger.

Si jamais vous demandez à l’aide de l’instruction first à chercher une valeur qui n’existe pas dans le vecteur prenons par exemple le chiffre 9 le compilateur proteste énergiquement.

le programme se plante avec une exception soulevée « sequence contains no matching element ».

Bon d’accord mais il aurait pu le dire gentiment.

Vous l’avez compris pour utiliser la fonction « first » il faut être sûr que la valeur existe sinon gare aux foudres du compilateur.

L’astuce serait donc d’utiliser l’instruction « Any » pour être sûr de l’existence de la valeur dont on recherche l’occurrence.              Une fois rassuré on fait appel à l’instruction first.

Int pos=0 ;

if (k.Any (b=>b==9))

{

pos = k.First (b => b == 9);

} else pos=-1 ;

Si au contraire vous êtes dans votre droit en cherchant un chiffre qui appartient au vecteur exemple :

if ( k.Any (b=>b==7))

{

pos = k.First (b => b == 7);

} else pos=-1 ;

Dans ce cas la fonction retourne le chiffre 7 pour nous informer que la valeur 7 existe bel et bien, c’est ce que nous savons déjà grâce à l’instruction any.

La fonction first semble donc tout à fait inappropriée pour une utilisation avec l’expression lambda.

D’ailleurs l’exemple officiel donné de l’utilisation de la fonction first n’emploie pas l’expression lambda.

First n’a en fait d’autres prétentions que de retourner le premier élément du tableau.

int[] k = { 2, 1, 2, 3, 5, 3, 4, 1, 6, 7, 8, 2, 1, 0, 8 };

int q= k.First();

q prend la valeur de 2 qui est effectivement la première valeur du vecteur k. Autant utiliser notre ancienne bonne méthode

int q= k[0] ;

Pour chercher la première occurrence d’une valeur dans un vecteur il est plus utile de passer par le casting « tolist ».

int pos = k.ToList().IndexOf(7);

pos prend la valeur 9 qui est effectivement le rang de la valeur 7.

Par contre si vous cherchez la valeur 8 qui est un doublon occupant à la fois les rangs 10 et 14 la ligne de programme

pos = k.ToList().IndexOf(8);

Renvoie   la valeur 10. C’est-à-dire la première occurrence de la valeur recherchée.

Vous l’avez remarqué la fonction indexof n’emploie pas l’expression lambda. Si vous vous obstinez à le faire l’erreur soulevée est similaire à celle soulevée lors de l’utilisation de l’expression lambda avec la fonction reverse.

l’avantage avec ‘indexof contrairement à first c’est que l’instruction ne se met pas dans tous ses états si la valeur recherchée n’existe pas elle se contente gentiment de retourner la valeur -1.

pos = k.ToList().IndexOf(9);

(40)

Opérations sur les vecteurs en c# en utilisant l’expression Lambda -2-

Opérations sur les vecteurs en c#  en utilisant l’expression Lambda

Par Ettougourti Mohamed Ali

Nous pouvons aller encore plus loin dans notre exploitation du nouvel outil de programmation que le c# nous offre à savoir l’expression lambda.

(voir article précédent).

L’on peut par exemple ajouter une valeur unique aux différentes valeurs d’un vecteur

x = x.Select(b => b += 0.3).ToArray();

Ou en soustraire une valeur donnée

x = x.Select(b => b -= 0.3).ToArray();

Vous l’avez deviné toutes les opérations arithmétiques sont possibles :

La multiplication:

x = x.Select(b => b *= 0.3).ToArray();

La division:

x = x.Select(b => b /= 0.3).ToArray();

Les précautions d’usage restent de mise pour la division par zéro qui nous donne « infinity » comme résultat.

Les valeurs absolues:

x = x.Select(b => Math.Abs(b)).ToArray();

l’élevation à puissance :

x2 = k2.Select(b => Math.Pow(b, 2)).ToArray();

Pour élever les valeurs de k2, un tableau de type int, à la puissance de 2 nous avons toutefois utilisé un tableau de type double x2 en tant que tableau de destination : Math.pow renvoie en effet une valeur double.

Ces précautions d’usage prises en compte il est possible avec l’expression Lambda d’effectuer toutes les opérations mathématiques sur un vecteur une seule fois et sans recourir à des boucles d’itération.

L’appétit vient en mangeant rien ne peut plus désormais freiner notre élan et l’on est en droit de se demander si d’autres opérations plus fines ne puissent être menées à bien sur des vecteurs.

Le c#  nous offre en matière de tableaux plusieurs instructions de nature à nous faciliter encore plus la tâche.

Ainsi il est possible d’éliminer les doublons d’un vecteur.

Pour ce faire on utilise la fonction ou la méthode « distinct ».

Si l’on initialise un tableau d’entiers avec plusieurs doublons exemple :

int[]k={2,1,2,3,5,3,4,1,6,7,8,2,1,0,8} ;

et si l’on fait appel à distinct() l’on verra qu’une seule valeur des doublons 2,3, 8 ,etc. est retenue et le tableau de rétrécir de 15 éléments à tout juste neuf éléments.

k2 = {2,1,3,5,4,6,7,8,0} ;

Je vois venir votre objection : dans distinct il n’y a pas de signe lambda qui vaille, pourquoi l’invoquer ?

Vous avez raison.  C’est pourquoi je me rattrape sur une autre méthode fort utile qui exige cette fois l’emploi de l’expression lambda.

La méthode sert à trier le tableau par ordre ascendant:

k2 = k2.OrderBy (b=>b).ToArray ();

En inspectant le tableau k2 l’on constate que le zéro initié à la fin du tableau prend désormais la première place et que toutes les valeurs sont bien ordonnées du plus petit au plus grand.

k2 = {0,2,1,3,5,4,6,7,8} ;

Vous ne voulez pas d’un ordre ascendant ?  La même expression lambda nous permet de trier le tableau dans l’ordre descendant du plus grand au plus petit

k2 = k2.OrderByDescending (b => b).ToArray();

Et le tour est joué:

k2 = {8,7,6,5,4,3,2,1,0} ;

Pour faire compliqué alors qu’on peut faire simple on peut évidemment ordonner les valeurs d’un tableau par ordre décroissant ou ascendant puis simplement inverser le tableau grâce à la fonction ou la méthode reverse.

k2.Reverse();

Mais comme vous le constatez l’expression lambda ne figure pas dans l’instruction reverse.

Si vous tenez à employer l’expression lambda dans reverse vous serez vite remis à l’ordre par le compilateur une erreur survient de type « cannot convert lambda expression to type array because it is not a delegate type ».

Ceci n’est pas très clair mais en gros le compilateur refuse d’y aller : ses désirs, comme chacun sait, sont des ordres.

Le plus intéressant reste évidemment de pouvoir travailler sur plusieurs vecteurs.

Pour ce faire nous allons initier un deuxième vecteur baptisé x2 de type double avec des valeurs aléatoire grâce au générateur de nombre aléatoires t précédemment créé.

double[] x2 = new double[100];

x2 = x2.Select(b => b = t.NextDouble()).ToArray();

Pour additionner les valeurs des deux vecteurs nous retrouvons donc notre variable d’itération, next ou index ou de  tout autre nom fantaisiste.(voir article précédent)

Si nous choisissons le vecteur x2 comme vecteur de destination la ligne de code doit s’écrire comme suit :

x2 = x.Select((b,next) => b + x2.ElementAt(next)).ToArray ();

Remarquez que nous pouvons référencer l’élément dans x2 directement à l’aide de deux accolades en reprenant le code sous cette forme:

x2 = x.Select((b, next) => b + x2[next]).ToArray();

C’est aussi avec la même insolite facilité que nous pourrons soustraire un vecteur d’un autre, multiplier deux vecteurs ou diviser l’un par l’autre.

x2 = x.Select((b, next) => b – x2[next]).ToArray();

x2 = x.Select((b, next) => b * x2[next]).ToArray();

x2 = x.Select((b, next) => b / x2[next]).ToArray();

il est tout aussi possible d’effectuer des opérations sur plusieurs tableaux:

x2 = x.Select((b, next) => b + x2[next]* k2[next]).ToArray();

Vous avez testé cette dernière ligne de code et vous avez constaté que ça ne marche pas ?

Autant  pour moi, j’ai oublié de vous parler d’ un détail important:  les tableaux doivent être de même taille d’où l’exception soulevée par le programme : « out of range » ou limites du tableau atteintes.

(164)

Utilisation de l’expression lambda dans les opérations sur les vecteurs en c sharp

Utilisation de l’expression lambda dans les opérations sur les vecteurs en c sharp :

Par Ettougourti Mohamed Ali

Les opérations sur les vecteurs, ou tableaux, ou arrays en anglais, occupent la plus large part du temps consacré à l’exécution des programmes informatiques.
Dans le c# sharp ainsi que dans d’autres langages l’expression           « lambda » est utilisée pour « standardiser » certaines opérations sur les vecteurs.
Nous en donnons dans cet article des exemples basiques :
Nous commençons par créer un vecteur ou un tableau de valeurs de type double

double []x = new double [100];

System.Random t = new Random();

Pour créer des valeurs aléatoires nous avons initié un générateur de valeurs aléatoires « t » que nous allons utiliser pour remplir le tableau « x » de valeurs aléatoires.
Pour ce faire nous allons utiliser l’expression lambda illustrée par le signe « => »
x = x.Select(b => b = t.NextDouble()).ToArray();
cette simple ligne nous permet d’économiser toute une boucle de for, next ou de do while.
Exemple d’ancien code:
for(int i=0 ; i< x.Length;i++)

{

x [i] =  t.NextDouble();

}

L’expression lambda permet aussi d’effectuer certaines opérations basiques sur le vecteur.

Ainsi il nous est possible de calculer la somme des valeurs contenues dans le vecteur :

double sum = x.Sum();

ou encore d’en calculer la moyenne arithmétique:

double average = x.Average ();

La même expression lambda nous permet aussi de trouver la valeur maximale du vecteur:

double max = x.Max ();

ou encore la valeur minimale du vecteur:

double min = x.Min();

il nous est même possible en transformant le tableau en « List » de chercher et trouver la position dans le vecteur de la valeur « min » et de la valeur « max »:

int position = x.ToList().IndexOf(min);

position = x.ToList().IndexOf(max);

l’expression “lambda” permet aussi de gérer de façon élégante           et en masse la conversion des valeurs contenus dans le vecteur d’un type à un autre.

Nous pouvons ainsi facilement convertir les valeurs doubles contenues dans le vecteur « x » en valeurs de type « float » ou « int » ou « short »..

Nous pouvons calculer la somme des valeurs contenues dans le vecteur comme si elles étaient de type int16 en opérant la conversion et en effectuant l’addition grâce à l’expression lambda

int int_sum = x.Select(b => System.Convert.ToInt32(b)).Sum();
une ligne de code utilisant l’instruction “Cast” ne marchera pas générant une erreur de type « system invalid cast exception ».
int int_sum= x.Cast().Sum();
grâce à l’expression lambda des opérations arithmétiques plus poussées peuvent être opérées sur les valeurs du vecteur.
On peut par exemple élever les valeurs du vecteur à la puissance deux, en determiner la somme puis la diviser lpar le nombre des valeurs contenues dans le vecteur.
Toutes ces opérations tiendront en une seule ligne de code
double y= x.Select(b => b * b).Sum() / x.Length;

Autres utilisations de l’expression lambda font appel à des mots tels que « next » et « index ».
C’est le cas si l’on veut opérer une accumulation sur une séquence des valeurs contenues dans le vecteur en recourant à la fonction « aggregate ».
double yy = x.Aggregate((b, next) => next + b);
Lorsque vous lancez le programme vous remarqueriez que la variable « yy » est égale à  la variable « sum » et que nous n’avons rien fait de plus que de calculer la somme des valeurs d’une autre façon.
Mais la fonction aggregate peut retrouver toute son utilité en l’employant avec une une autre instruction  telle que « where » par exemple.
Il nous sera possible dés lors de calculer la somme de certaines valeurs choisies selon un critère bien précis.
Exemple de code:
double yy = x.Where (b=> b> 0.5).Aggregate ( (b, next) => next + b);
en vérifiant vous remarqueriez que seules les valeurs supérieures à 0.5 ont été prises en considération dans le calcul de la somme des valeurs.
Le mot « next »  n’est pas un mot clef il peut-être remplacé dans la ligne de code précédente par le mot « index » sans que les résultats changent.
double yy2 = x.Where(b => b > 0.5).Aggregate((b, index) => index + b);
En vérité le mot “next” ou “index” peuvent être tout aussi bien remplacés par tout autre mot par exemple « suivant », ou même « chat » sans protestation aucune du compilateur.

et voici le code source des  exemples donnés

 

private void samples ()
{
double []x = new double [100];

System.Random t = new Random();
x = x.Select(b => b = t.NextDouble()).ToArray();
double sum = x.Sum();
double average = x.Average();
double max = x.Max();
double min = x.Min();
int position = x.ToList().IndexOf(min);
position = x.ToList().IndexOf(max);

//instruction générant erreur 
//int int_sum= x.Cast<int>().Sum();

int int_sum = x.Select(b => System.Convert.ToInt32(b)).Sum();
double y= x.Select(b => b * b).Sum() / x.Length;

double yy1 = x.Where(b=> b> 0.5).Aggregate((b, next) => next + b);
double yy2 = x.Where(b => b > 0.5).Aggregate((b, suivant ) => suivant + b);
}

(61)