Archives par mot-clé : csharp projects

lambda expression in csharp sample of musical notes Array

lambda expression in csharp sample of musical notes Array

By Mohamed Ali Ettougourti

The second example in csharp we offer in illustration using the lambda expression to the arrays is one of a musical..Notes array.
First create a special structure for the musical note.
The musical note is characterized by its name (Italian names do, re, mi, fa, sol, la, si)  or imperial (c, d, e, f, g, a, b).

It is also characterized by its height or range to which it belongs in musical instrument digital interface or “midi” standard there are almost 10 ranges. Midi values will indeed from 0 for very low to a strident “sol” or “g”. 12 ranges each one containing 12 different notes.
A musical note is also characterized by its duration and velocity that is to say, the force with which it is played.

It is also characterized by its frequency. Music using the quarter tone requires greater acuity in the frequency « right » of the note.
To make it simple we will limit ourselves to some characteristic or

-The “midi” value of the note,

its duration,

and velocity.
Translated into our code structure can be presented as follows:
public struct note
{

public int val_midi;

public int length;
public int velocity;

}
To complete our new data we use the random number generator provided by the csharp.
We want duration are between 1 and 64 for the round and for shortest note.
For notes we want them to be between 41 to a low F or ‘FA’ and 62 for D or “RE”.
for the velocity : zero for rests and 127 for the largest, we choose a row between 0 and 80.
To avoid generating odd times do not correspond to the nature of musical time we initialize an array of acceptable times we will call d.
int [] d = {1, 2, 4, 8, 16, 32, 64};
Avoiding dotted notes.
We can force the random number generator to provide values in rows requested by the next function generator.
The initialization of our array musical notes can be made by writing a single line of code through the use of the lambda expression.
int [] d = {1, 2, 3, 4, 8, 16, 32, 64};

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

Once the table is filled, we used the lambda expression to inspect, sort, change the musical notes.
We can start for example by knowing the time length of the music generated assuming the tempo to 60 quarter duration per minute

The following line of code allows us to do it
double totalduree =
n.Where (b => b.duree == 1) .Count () * 4 + // whole  note

dn.Where (b => 2 == b.duree) .Count () * 2 + / / half 
n.Where (b => b.duree == 4) .Count () * + 1 / /  quarter

// For the quarter divisions
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;
The total recovered in the double variable totalduree is divided by 60 to find the number of minutes required for an instrument to perform the musical piece generated quite randomly.
We can also consider guess the musical piece mode generated by counting the occurrence of different notes and prevailing gaps between them.
To do this we use two nested lambda expressions at once this will allow us to count the number of different notes occurrences on the musical piece that result which we hasten to save it in an array created ad hoc.

int [] g = new int [12];

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

g array is created to receive the number of occurrences of the 12 natural or altered musical notes.
The same array is used with the « next » variable to find using the « where » instruction notes whose “midi” value modulo 12 is equal to « next » and to count the occurrences.
I do not know what kind of music you will get for the piece of code just written.

For me I find that the dominant note is F # or f#, that the « la » or « a » flat and the  » si « or » b « flat are also so present which suggests a piece in F sharp Major !!
Why not listen to the music generated making this lecture enjoyable as well as useful ?

(29)

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 (109 téléchargements)

(81)

The lambda expression in C # moving up another gear

The lambda expression in C # moving up another gear
by Ettougourti Mohamed Ali

 

You would be surprised to learn that we have done in our previous section touched easy aspects of using the lambda expression with vectors and arrays.
The « normal » use relates the well-known conventional vectors.
But what if we plan to use vectors of a particular type?

A vector class or structure defined by us?
Two examples: the first milking fractions vector,

the second relates to a vector of musical notes.

In both cases structure are defined by us.
Let’s start with the first example by creating together a special class which is called « fraction »

Class fraction {};

To be visible from all public we qualify the class as public.
Public class fraction {};
Two constructors are provided to initialize the class:
Public fraction (int d);
And
Public fraction (int n, int d);
The first constructor assumes the numerator of the fraction equal to 1.

The instruction
New fraction (2);
Gives a fraction of a half 1/2 ..

The second most explicit constructor requires and the numerator and the denominator.
The instruction
New fraction (2, 4);
Gives a fraction of 2/4 two quarters or a half.
Here is all the concocted code.

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

We propose to create a vector of class fractions that we simply appoint x.

Fraction x = new fraction [5];

Initializing the array with a series of 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);

The challenge we face is to use the lambda expression to process data of the vector x to find the maximum, the minimum and their respective positions for example.

The flood instruction

fraction max= x.Max ();

Will cause a compiler error because the fraction class contains no CompareTo () method that would allow comparison between the different elements of the vector. CompareTo method is necessary to find the maximum and the minimum values.
The compiler standing by its CompareTo method we must comply.
We resume therfore our code written for the « fraction » class by declaring the fraction base class IComparable.

public class fraction: IComparable
And then just adding a CompareTo method.

int CompareTo (object obj)

{

fraction f = (fraction) obj;

int n = f.num * den;

int d = f.den * den;

int num = n2 * f.den;

int d2 = den * f.den;

if (n == n2) return 0;

else if (n2> n) return 1;

return -1;

}

The CompareTo method begins by calculating the common denominator between the two fractions.

If both are equal numerators our method returns zero to say that both fractions are equal if n2 is greater than n the method returns 1 otherwise it returns -1;

Our fraction rewritten class now looks like the following code:

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 num = n2 * f.den;

int d2 = den * f.den;

if (n == n2) return 0;

else if (n2> n) return 1;

return -1;

}

}

we can now safetly seek the greatest value of the vector x.

fraction max = x.MAX();

Or

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

Max takes the value of 1/4;

The instruction

Fraction min = x.Min();

Or

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

refers 1/24;

To sort the vector from the smallest fractions to the largest we can still use the lambda expression with instruction orderby

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

the vector x is now ordered as follows

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

The instruction

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

Operates a descending sort.

The reverse statement is also operational.

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

The instruction indexof already encountered works just as well.

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

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

(18)

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

 

 

 

 

 

 

 

(46)

use of lambda statement in C # 3

use of lambda statement in C #

by Mohamed Ali Ettougourti

 

Our study of  lambda expression use n in c sharp continues.

Driven by curiosity that programming needs justify we can ask if the vector object of our attention has a single value that continues throughout the vector as length and as big as it is.

The lambda expression  is a good relief because we can use the query « All » to see if all the values of a vector are identical.

The statement « all » returns a Boolean value « yes » or « no », true or false.

So back to our vector k int initiated in the previous articles we can examine to see if all vector values are zero.

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

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

the function returns false  what is true because some values of the vector k are different from 0.

One can ask on a different way to see if all values are greater than 0.

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

the answer is always negative since we know a glance to the vector k is a value at least equal  to zero.

Exasperated we want to finish by asking directly and frankly the question: is there any value in the vector that is zero?

This is the Any instruction that comes to our rescue, our curiosity will be satisfied

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

Once the variable “v” is true and the answer is positive.

Some propose to assure the existence of a zero value in our vector k we taking differently but always using the valuable services of our lambda expression.

It is true that c sharp offer another instruction that seems a priori meet the same spots.

The « first » instruction, since it is from which it comes, would check for a value in a vector.

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

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

if it is true that the first instruction using the lambda expression confirms our intuition of the existence of a value equal to 3 belonging to the vector,  the instruction, however, merely refers quite simply the desired value.

By inspecting the variable « occ » we « discovered » no surprise it  is equal to 3. What we know already. Thanks anyway.

The instruction « first » seems unnecessary especially when checking we discover that the instruction really has a very bad temper. You be the judge.

If you ever ask the help of the first instruction to search for a value that does not exist in the vector take for example the number 9 the compiler strongly protests.

the program plant with an objection « sequence contains no matching element. »

Okay but could have said sweetly.

You understood to use the « first » function must be sure that the value is, otherwise beware the wrath of the compiler.

The trick would be to use the « Any » instruction to be sure of the existence of the value of which is sought here. Once reassured we appealed to the first instruction.

Int pos = 0;

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

{

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

} Else pos = -1;

If instead you are within your rights in seeking a number that belongs to the vector example:

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

{

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

} Else pos = -1;

 

In this case the function returns the number 7 to inform us that the value 7 exist, it is what we already know from the « any » instruction.

The “first” function seems completely inappropriate for use with the lambda expression.

Moreover, the official example given of the use of the first function does not use the lambda expression.

First have in fact no other pretensions than to return the first element of the array.

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

int q = k.First ();

q takes the value of 2 which is actually the first value of the vector k.

As well use our old good method

int q = k [0];

To find the first occurrence of a value in a vector it is more useful to go through the casting « tolist ».

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

pos is set to 9, which is actually the rank of the value 7.

By cons if you want the value 8 which is a duplicate covering both rows 10 and 14, the program line

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

Returns the value 10. That is to say, the first occurrence of the desired value.

You noticed the “indexof” function does not use the lambda expression.  If you persist in doing so raised an error similar to the one raised when using the lambda expression with reverse function.

the advantage with ‘indexof unlike « first » function  is that the instruction does not turn into a tizzy if the required value does not exist it gently simply return -1.

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

(10)

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

(28)

TRANSACTIONS IN VECTORS C # USING LAMBDA EXPRESSION -2-

TRANSACTIONS IN VECTORS C # USING LAMBDA EXPRESSION -2-

 

By Mohamed Ali Ettougourti

 

We can go even further in our operation of the new programming tool that C # offers to us : the lambda expression.

(See previous article).

One can for example add a unique value to different values of a vector

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

Or subtract a given value

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

You guessed all arithmetic operations are possible:

The multiplication:

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

The division:

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

The precautions are still required for the division by zero which gives us « infinity » as a result.

The absolute values:

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

the elevation to power:

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

To raise the k2 values, an array of type int, to the power of 2, however, we have used an array of double x2 such as an destination array : Math.pow returns indeed a double value.

These precautions taken into account all basic operations seem possible with the expression Lambda on a vector once and without iteration loops.

Appetite comes with eating nothing can now halt our momentum and we are entitled to ask whether other finer operations cannot be carried out on vectors.

C # we offer on several instructions to assist us and make our job even easier.

Thus it is possible to eliminate duplicates from a vector.

To do this we use the function or the « distinct » method.

First we initialize an array of integers with several duplicates example:

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

if one uses distinct () we will see one value duplicates 2.3, 8, etc.   retained and array shrink from 15 items to just nine items.

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

I see coming your objection no lambda sign in distinct method, why invoke it?

You are right. This is why I  invoke  another useful method that requires this time the use of the lambda expression.

The method used to sort the table in ascending order:

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

 Inspecting k2 array we see that the zero initiated at the end of the table now takes first place and that all values are ordered from smallest to largest.

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

You do not want an ascending order?  The same lambda expression allows us to sort the table in descending order from largest to smallest

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

And voila:

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

To do so complicated that we can make it simple we can obviously order the values of an array  by ascending  order then “simply”  reverse the array using the reverse function or method.

k2.Reverse ();

But as you see the lambda expression is not in the reverse instruction.

If you insist on using the lambda expression in reverse method you will be quickly delivered to the order by the compiler on error type « can not convert lambda expression to type of array Because it is not a delegate type ‘.

This is not very clear but basically the compiler refuses to go: his desires, as everyone knows, are orders.

The most interesting is obviously to work on multiple vectors.

To do this we will initiate a second vector called   x2  of type double with random values using the random number generator t previously created.

double [] = x2 dual new [100];

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

To add the values of the two vectors so we find our iterator variable, index or next or any other fancy name. (See previous article)

If we choose the vector x2 as destination vector line of code should be written as follows:

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

Note that we can reference the element in x2 directly with braces by putting a code in this form:

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

It is also unusual with the same ease that we can subtract a vector of another multiply two vectors or divide one by the other.

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

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

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

it is also possible to perform operations on several arrays:

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

You tested this last line of code and have found that it does not work?

So much for me, I forgot to tell you about one important detail: the arrays should be the same size if not   exception   is raised by the program : « out of range » .

(20)

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.

(144)

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

(52)