Discussion :

[Pierre Fauconnier]

Salut.


Exclusivité Excel 365


La fonction LAMBDA, on en parle depuis longtemps.

Elle est apparue dans les versions Insider d'Office, mais elle est maintenant disponible, en tout cas sur ma version (Microsoft 365 apps for Entreprise) =>

Cette fonction permet de mémoriser une formule en lui donnant un alias, et de passer des arguments à cette formule et donc, de la transformer en fonction. On avait déjà LET qui permet d'utiliser des variables au sein d'une formule, que Lambda vient compléter pour donner encore plus de puissance à vos formules Excel. Sa syntaxe est simple:

Code excel :

Sélectionner tout - Visualiser dans une fenêtre à part

=LAMBDA(Par1;Par2;...;ParN;Formule utilisant les arguments)

On pouvait déjà, par le passé:

• créer des fonctions personnalisées en VBA, mais il faut savoir programmer, d'une part, et d'autre part cela transforme le fichier en xlam, amenant un risque de sécurité;
• créer des formules nommées, mais cela imposait une conception de classeur puisque les formules nommées sont liées à des cellules.

Dans un prochain billet, j'illustrerai ces deux méthodes.


La fonction LAMBDA permet d'oublier le VBA, si la formule est exprimable en Excel, et découple la formule de la cellule dans laquelle elle est utilisée.


Elle permet de créer une fonction dans Excel que l'on utilise comme une fonction native. Prenons comme exemple le calcul du volume d'un cylindre dont on connaît le diamètre et la hauteur. Ok, on peut le faire par formule: = (A2/2)^2*PI()*B2, avec A2 pour le diamètre et B2 pour la hauteur. Et comme on peut le faire par formule, on peut utiliser LAMBDA. Il pourra alors être intéressant d'avoir une fonction toute faite: =VolumeCylindre(A2,B2).




Sympa, non? Et bien, LAMBDA permet de réaliser cela, et facilement, en plus.

On crée une fonction en trois temps:

1. On écrit la formule;
2. On teste La fonction LAMBDA sur la feuille;
3. On enregistre cette fonction LAMBDA dans le gestionnaire de noms et on lui donne le nom souhaité.

1ère étape




2ième étape

On inclut la formule dans la fonction LAMBDA en:

1. spécifiant d'abord les arguments (Diamètre et hauteur);
2. remplaçant les références de cellule par les arguments, et l'on note que l'infobulle d'aide à la saisie propose les arguments définis en début de fonction;
3. passant les arguments, entre parenthèses, après la parenthèse de la fonction Lambda (comme on le ferait pour n'importe quelle fonction native d'Excel.

3ième étape

1. On copie la formule sans les arguments utilisés pour la tester;
2. On crée une fonction nommée dans le gestionnaire de noms;
3. En référence, on colle la formule utilisant LAMBDA.

A cette étape, on peut également ajouter une légende qui apparaitra en infobulle lors de la sélection de la fonction. A noter que, actuellement, cette description n'est pas reprise dans l'assistant Fonctions.





Utilisation

On utilise la fonction comme une fonction native d'Excel.




La fonction est utilisable partout dans le classeur. Vous devrez la recréer dans chaque classeur dans lequel vous souhaitez l'utiliser. Un OneNote vous permettra de sauvergarder le code de la fonction dans votre bibliothèque de codes.

Bien sûr, j'ai détaillé les étapes ici pour la prise en main de cette nouvelle fonction, mais vous pouvez évidemment saisir directement la fonction Lambda sans passer par l'étape 1, et rédiger la formule à l'intérieur de la fonction Lambda... Il est tout à fait possible de saisir la formule directement dans le gestionnaire de nom en l'encapsulant dans la fonction LAMBDA ou, pour la tester, la saisir dans une cellule, là aussi encapsulée dans LAMBDA. Toutefois, pour les formules un peu complexes, l'étape 1 peut être intéressante.



Et pour vous, cette fonction est disponible?

N'hésitez pas à la tester et à commenter ici vos impressions sur l'utilité de cette fonction.

[Pierre Fauconnier]

Au delà de de la théorie sur la fonction, LAMBDA permet de simplifier la vie de l'utilisateur Excel, en mémorisant des formules dans des fonctions "clé sur porte". Quelques exemples parmi d'autres.


Calcul du trimestre

Il est parfois intéressant de retrouver le trimestre auquel appartient une date. Excel propose d'ailleurs cela dans les tableaux croisés dynamiques, ou la date est automatiquement éclatée en Année/Trimestre/Mois/Jour. Mais Excel ne propose pas (encore) de fonction TRIMESTRE. LAMBDA permet de pallier ce manque.

Calculer le trimestre d'une date s'effectue avec la formule =ENT((MOIS(MaDate)-1)/3)+1. Il serait dès lors intéressant d'avoir la fonction TRIMESTRE, qui permettrait de faire abstraction de la formule:





"Faire" du RECHERCHEX sans le savoir (1)

Pour simplifier la recherche de valeurs dans une liste, on peut camoufler le RECHERCHEX derrière une fonction LAMBDA. Avec le tableau suivant nommé t_Contacts, on peut proposer à l'utilisateur une fonction pour retrouver rapidement le prénom d'un contact sur base de son matricule:






"Faire" du RECHERCHEX sans le savoir (2)

En utilisant INDIRECT, on peut généraliser la fonction pour retrouver la valeur de n'importe quelle colonne avec une fonction qui serait par exemple =CONTACT_CHAMP(Matricule; Champ).






A vous, maintenant, de trouver d'autres utilisation de cette fonction qui permet aux utilisateurs de vos classeurs de faire abstraction des fonctions natives pour utiliser les fonctions "orientées classeur" que vous mettrez à leur disposition.

[78chris]

Bonjour

Dispo aussi sur 365 famille

Merci pour ces exemples

[Raccourcix]

Merci Pierre
En parallèle à LAMBDA, il y a également une nouvelle série de fonctions "MAKEARRAY" sur 365 Famille (je n'ai pas la dernière version au bureau)
- MAKEARRAY
- SCAN
- MAP
- BYCOL
- BYROW
- REDUCE
Ces fonctions ne sont pas traduites en français, les noms d'origine ont été conservés.

Cela semble intéressant, à voir à l'usage. J'ai déjà beaucoup de collègues perdus avec les fonctions matricielles, l'utilisation des références A1#, ... J'ai peur que les utilisateurs "lambdas" soient un peu dépassés par ces formules.
Les formations sont importantes mais pour que chacun s'approprie les nouveautés il faut pratiquer et là bien souvent on repart sur les bases connues et non sur ces nouveaux concepts.

Stéphane

[Pierre Fauconnier]

@Stéphane


Je suis en train d'écrire un tuto sur LAMBDA, LET et les fonctions liées à LAMBDA que tu cites ici. Je nourrirai le tuto avec des exemples que j'espère pertinents


@Chris

Merci sur l'info relative à la disponibilité. Cela signifie que Lambda et ses dérivées sont disponibles sur les versions 365 normales (hors Insider)

[Pierre Fauconnier]

Suite à cette discussion, petite création de fonction perso avec LAMBDA et LET pour permettre une saisie rapide d'un "temps". L'idée est de saisir une valeur horaire sans les séparateurs et la virgule pour les parties de secondes:
1243564 => 12:43:56,4

On crée une lambda que l'on enregistre dans le gestionnaire de noms et on lui donne un nom valide qui sera celui de la fonction utilisable en Excel. Dans l'exemple, j'ai nommé la lambda ConversionSaisie. La fonction ici illustre que LET peut utiliser les arguments de LAMBDA et que les variables de LET peuvent utiliser les variables qui ont été déclarées avant elles (H utilise T qui utilise V...)

Code Excel :

Sélectionner tout - Visualiser dans une fenêtre à part

=LAMBDA(v;LET(t;TEXTE(v;"0000000");h;GAUCHE(t;2);m;STXT(t;3;2);s;STXT(t;5;2);n;DROITE(t;1);SI(ET(m>="00";m<="59";s>="00";s<="59");h/24+m/1440+s/86400+n/864000;#VALEUR!)))

Il y a moyen de vraiment bien s'amuser

[Pierre Fauconnier]

On continue avec les fonctions REDUCE et LAMBDA.

J'ai montré une utilisation de LAMBDA qui consiste à enregistrer une formule Excel en l'incluant dans LAMBDA => =LAMBDA([Arg1], [Arg2],..., [Arg127],Formule) dans le gestionnaire de noms puis en l'utilisant comme une fonction native à laquelle on passe les arguments requis.

Mais comme l'a précisé Stéphane, on peut utiliser LAMBDA en combinaison avec d'autres fonctions, et notamment REDUCE qui fonctionne en boucle pour ramener le résultat final dans une cellule.

Explications


Soit à devoir supprimer les chiffres contenus dans une cellule pour ne garder que les lettres.



En découpant le process, on peut comprendre que l'on va devoir remplacer 1 par "" dans la chaine initiale pour créer la chaine 1, puis 2 par "" dans la chaine 1 pour créer la chaine 2, ..., puis 0 par "" dans la chaine 9 pour créer la chaine finale.




REDUCE, associée avec LAMBDA, va permettre cela, en partant d'une valeur initiale et en bouclant sur toutes les valeurs d'un tableau pour appliquer le LAMBDA.

Syntaxe: REDUCE(ValeurInitiale; Matrice; Lambda(Arg1, Arg2, Formule)) dans laquelle Arg1 = ValeurInitiale et Arg2 = Matrice.

Important: Il faut comprendre ici que Matrice peut être un tableau structuré (souvent une colonne de ce tableau), mais aussi une matrice constante.

On remarque avec cette syntaxe que le Lambda reçoit ValeurInitiale et Tableau comme arguments 1 et 2. REDUCE va partir de la valeur initiale puis boucler autant de fois qu'il y a de valeurs dans le tableau pour appliquer le LAMBDA à chaque boucle et repartir du résultat intermédiaire obtenu pour la boucle suivante. Le résultat renvoyé par REDUCE est donc la valeur transformée après toutes les boucles.

C'est donc bien le processus illustré ci-dessus, qui boucle 10 fois pour remplacer à chaque passage la valeur x de la matrice par du vide.




Autre exemple

Dans un texte contenant des caractères "HTML", remplacer les caractères HTML par leur équivalent ASCII...



Le principe est identique, à savoir parcourir un texte en bouclant sur les caractères à remplacer, sauf que dans ce cas-ci, les caractères ne sont pas remplacés par "" mais par un caractère différent à chaque fois. Autrement dit, on va passer une table de correspondance qui permettra d'effectuer les remplacements par boucle. Le problème est que l'on ne peut passer qu'une matrice alors que l'on a besoin de deux, les caractères HTML et les caractères de remplacement. Ici, C1 contient un espace.



Ce problème n'existe pas si l'on accepte l'idée que l'on va rechercher les valeurs d'une matrice dans une colonne d'un tableau structuré pour récupérer les valeurs correspondantes dans une autre colonne du même valeur structuré.



On voit donc ici qu'au départ de ValeurInitiale (A1), on va rechercher chaque caractère d'une matrice (la colonne HTML du tableau) dans la colonne HTML du tableau pour le remplacer par le caractère de la colonne Ascii du tableau. On retrouve donc ici les deux variables nécessaires à REDUCE... Du coup, on peut boucler en une seule formule.

[Pierre Fauconnier]

Après Lambda pour créer des fonctions personnalisées, nous avons vu que nous pouvions créer des formules "qui bouclent", un peu comme des matricielles, avec REDUCE et LAMBDA.

Ici, nous allons approcher MAP et LAMBDA pour permettre de récupérer des données sous conditions dans des plages dynamiques, voire de les sommer pour récupérer le total.


SOMME.SI.ENS permet de sommer des valeurs en fonction de plusieurs critères dont le nombre varie de 1 à 127. Mais ces critères doivent tous être validés pour que la ligne du tableau soit prise en compte: Critère1 ET Critère2 ET Critère3... Il n'est pas possible avec SOMME.SI.ENS de tester Critère1 OU Critère2, ni Critère1 OU ((Critère2 ET Critère3) ou (Critère3 ET Critère4))... Jusque maintenant, on devait se tourner vers SOMMEPROD ou une formule matricielle, validée avec MAJ+CTRL+ENTER. La version 365 apporte une solution qui, avant l'apparition de MAP et LAMBDA, permettait de simplifier un peu la formule, mais qui obligeait de passer par la case "arithmétique booléenne".


Le problème est qu'il faut savoir jongler avec l'arithmétique booléenne qui nous permet de transformer VRAI et FAUX en 1 et 0, permettant d'établir des tables de vérité complexes, mais délicates à écrire en Excel. En effet, ET et OU ne peuvent pas être utilisées dans une matricielle puisque leur utilité est de renvoyer UNE valeur booléenne, VRAI ou FAUX, pour une matrice qu'elle reçoivent en argument. Malgré la matricielle, ET et OU renvoient donc UNE valeur et non pas une matrice de valeurs.



MAP et LAMBDA permettent de "retomber sur nos pattes" en proposant aux formulistes une approche plus conforme à leur utilisation habituelle de ET et OU.

Syntaxe: MAP(Matrice1; [Matrice2]; [Matrice3; ...; [Matrice127];LAMBDA(Arg1; [Arg2]; [Arg3]; ...; [Arg127];Formule)) dans laquelle il y a correspondance entre les MatriceN et les ArgN: Arg1 = Matrice1, Matrice2 = Arg2, ... On veillera donc à avoir autant de Arg dans le LAMBDA que de Matrice dans le MAP.


Exemple:

Soit à sommer les montants lorsque l'employé est Alain Térieur OU que le département est celui des achats...





On pourra bien sûr toujours s'en sortir avec des colonnes supplémentaires, mais je n'aime pas, car les tableaux sont alors assez vite ingérables. On peut y aller avec beaucoup de colonnes ou peu de colonnes. Examinons plus en détails la deuxième image qui rassemble différentes colonnes intermédiaires, car c'est sur le modèle de cette formule conditionnelle que nous travaillerons avec MAP et LAMBDA





Dans le cas présent, on pourrait s'en sortir avec une série de 3 SOMME.SI.ENS, car les conditions s'y prêtent, mais d'autres cas de figure rendront cette solution impossible à mettre en place





On pourrait utiliser SOMMEPROD ou une SOMME matricielle, mais au prix d'une arithmétique booléenne qui paraît parfois ésotérique au formuliste puisque ET et OU sont exclus des matricielles.





Avec Excel 365, on peut également utiliser FILTRE qui filtre un tableau ou une colonne d'un tableau sur bases de conditions. Là aussi, savoir manipuler l'algèbre booléenne est indispensable dès lors que l'on sort d'une simple condition a ET b.






C'est ici que MAP et LAMBDA vont nous aider.

L'idée consiste à passer chaque colonne du tableau nécessaire au calcul à MAP, qui va utiliser un LAMBDA en boucle sur chaque ligne des tableaux, en considérant qu'à chaque boucle, on travaille sur une ligne particulière. On peut alors sans problèmes utiliser ET et OU comme dans une formule Excel "normale" pour créer un vecteur de résultat sous forme d'une plage dynamique. Une simple SOMME sur cette plage permettra de récupérer le montant des lignes qui correspondent aux conditions exprimées.

MAP va recevoir les colonnes du tableau nécessaire à l'évaluation des conditions ainsi que la colonne reprenant les montants. LAMBDA va recevoir ces colonnes en arguments et il suffira d'exprimer la formule en utilisant les arguments "comme si on la rédigeait pour une ligne de données"... Du coup, on peut utiliser les fonctions ET et OU comme dans la seconde illustration de la solution avec colonnes supplémentaires.



MAP construit donc une plage dynamique, et on peut alors l'englober dans une simple fonction SOMME.




LAMBDA, associée à MAP, permet donc l'expression des conditions avec ET, OU, OUX et évite de devoir jongler avec l'algèbre booléenne.

[Pierre Fauconnier]

Avec REDUCE et LAMBDA, nous avons vu que nous pouvions créer une formule qui boucle et qui se sert à chaque boucle du résultat intermédiaire résultant des boucles précédentes. Pour rappel, sa structure est =REDUCE(ValeurInitiale; Tableau; LAMBDA(Arg1; Arg2; Formule)) où Arg1 et Arg2 correspondent respectivement à ValeurInitiale et Tableau.

SCAN possède la même syntaxe que REDUCE ( SCAN(ValeurInitiale; Tableau; LAMBDA(Arg1; Arg2; Formule)), mais renvoie le tableau des résultats intermédiaires alors que REDUCE renvoie la dernière valeur de ce tableau. Donc, si vous avez compris REDUCE, vous allez comprendre SCAN...

Reprenons l'exemple vu avec REDUCE pour supprimer les chiffres présents dans une chaîne de caractères:




On voit bien qu'à chaque "passe", on s'est servi du résultat de la passe précédente: A2 supprime 1 de A1, A3 supprime 2 de A2,.... En 10 passes, on a supprimé les 10 caractères numériques et REDUCE affiche l'unique résultat final.

Scan va procéder comme REDUCE en créant la plage dynamique des résultats intermédiaires. (Astuce: Ici, pour ne pas saisir la matrice constante, j'ai utilisé Ligne(A1:A10...))





Rien de bien compliqué, donc.


Cas pratique


Soit à trouver le plus grand nombre de cellules vides consécutives d'une plage... On peut bien sûr passer par une colonne intermédiaire qui "remet le compteur à zéro" dès qu'une cellule n'est pas vide, et qui incrémente le résultat précédent si la cellule est vide... Il suffit alors de prendre le max de la plage des résultats et on obtient notre donnée. Dans l'exemple ci-dessous, la plage A7:A11 est la plus grande plage vide de A2:A14 et contient 5 cellules vides. On comprend, avec la formule illustrée =SI(ESTVIDE(A2);D1+1;0) que l'on incrémente le résultat précédent sauf si la cellule n'est pas vide, auquel cas ce résultat partiel devient 0, et on recommence à compter. C'est bien ainsi que l'on arrive à 5...




Mais... Attendez... Compteur, incrément? Mais alors, SCAN et LAMBDA, bien sûr!!

A chaque boucle de LAMBDA, la valeur de Arg1 de LAMBDA est modifiée par la boucle et sert de nouvelle valeur initiale pour la boucle suivante. SCAN crée donc la plage dynamique des résultats intermédiaires, et il suffit d'en calculer le maximum avec MAX...





Voici donc un nouvel exemple d'utilisation de ces fonctions attachées à LAMBDA.

Bon travail et bon weekend

[fouziel]

Bonjour,

Je ne trouve pas trace de LAMBDA et des autres fonctions que vous citez dans ma version d'Excel (Build 16.0.14931).

J'ai tenté une mise à jour mais rien n'y fait.

Avez-vous des idées ? Voici ma version du produit.
Merci

[Raccourcix]

Bonjour

Pierre Fauconnier a présenté l'année dernière les potentialités de la fonction LAMBDA.
Il a montré comment l'utiliser seule via le gestionnaire de nom, ou comment la combiner avec les nouvelles fonctions comme SCAN, MAP, REDUCE, MAKEARRAY

Via le gestionnaire de nom, cette fonction est également très intéressante car elle peut être utiliser de manière récursive.

Je voudrais illustrer toutes ces possibilités avec le calcul d'une image bien connue d'une fractale "ensemble de Mandelbrot" sous Excel avec seulement une formule nommée, une fonction en A1 et une mise en forme conditionnelle.



Quelques explications simplifiées, j'espère que les spécialistes ne m'en tiendront pas rigueur

Chaque point du plan (coordonnées x, y) correspond à un nombre complexe z = x+yi. On créé une suite z_n+1 = z_n²+z₀. Si la distance à l'origine du point z_n (la norme) reste faible (norme <2 soit x²+y²<4) le point appartient à l'ensemble.
Le principe pour "dessiner" l'image, est de calculer à quelle itération de la suite la norme de zn dépasse le seuil, avec une limite de nombre d'itérations (précision de calcul).
En partant du point z₀=x₀+iy₀, la partie réelle est x_n+1=x_n²-y_n²+x₀ et la partie imaginaire y_n+1 = 2x_n*y_n+y₀

Au final, on a 7 paramètres
- un point de départ avec 2 coordonnées x0 et y0
- un calcul d'itération xn et yn
- un index d'itération j avec un nombre max j_max
- un seuil pour sortir si la norme dépasse 2 (donc x²+y²>4)

Je défini une fonction nommée "Mandelbrot"

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
=LAMBDA(
	x0;
	x;
	y0;
	y;
	j;
	j_max;
	seuil;
	SI(
		OU(
			(x*x+y*y)>seuil;
			j>j_max);
		i;
		Mandelbrot(
			x0;
			x*x-y*y+x0;
			y0;
			2*x*y+y0;
			j+1;
			j_max;
			seuil
		)
	)
)

Cette fonction commence par les 7 paramètres, puis une fonction SI permet la sortie du calcul : si la norme dépasse le seuil ou si on dépasse le nombre d'itérations, on renvoie l'index de la dernière itération. Sinon on rappelle la fonction Mandelbrot de manière récursive avec les nouveaux paramètres :
4 paramètres sont fixes : x0, y0, j_max et le seuil
3 sont modifiées : x = x²-y²+x₀ ; y = 2*x*y+y₀ et j = j+1

Ensuite on va utiliser cette fonction dans un MAKEARRAY
après quelques tatonnements, j'ai déterminé la partie du plan et la défitition du rendu :
260 lignes en partant de y_max = 1,3 et un pas négatif de -0,01 soit un y_min = -1,3
260 colonnes en partant de x_min = -2,05 et un pas de 0,01 soit un x_max = 0,55

La fonction MAKEARRAY, commencera donc par MAKEARRAY(260;260;LAMBDA(y;x;
les y en ligne, les x en colonne vont prendre les valeurs de 1 à 260 dans toutes les 260 lignes/colonnes.

exemple de MAKEARRAY


Dans notre cas, les coordonnées du point seront déterminées par
absice = -2,05+x*0,01
ordonnée = 1,3-y*0,01

Il ne reste plus qu'à appliquer la fonction Mandelbrot avec 0 pour débuter l'itération, 40 itérations max et un seuil de 4
Mandelbrot(-2,05+x*0,01;-2,05+x*0,01;1,3-y*0,01;1,3-y*0,01;0;40;4).

en cellule A1

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
=MAKEARRAY(
	260;
	260;
	LAMBDA(
		y;
		x;
		Mandelbrot(
			-2,05+x*0,01;
			-2,05+x*0,01;
			1,3-y*0,01;
			1,3-y*0,01;
			0;
			40;
			4
		)
	)
)

La formule va être calculée pour les plus de 67000 cellules et elle renvoie le nombre d'itérations avant la sortie (soit norme >2, soit 40 itérations atteintes). Plus de 800 000 itérations en tout. Quelques secondes de calcul sur mon PC

Je termine avec une mise en forme conditionnelle sur la plage A1# à 3 couleurs (mais malheureusement, l'adresse n'est pas dynamique suivant le MAKEARRAY) et j'ajuste la hauteur des lignes et la largeur des colonnes

Au final on obtient cette image avec seulement :
- une formule nommée (utilisant LAMBDA, SI, OU),
- une formule en A1 (utilisant MAKEARRAY, LAMBDA)
- une mise en forme conditionnelle.

Cela démontre la puissance de la formule LAMBDA récursive.

2023_01_23 Mandelbrot.xlsx

Je vais préparer un fichier pour adapter cet exemple afin de générer des ensembles de Julia (la fonction sera la même, il y a quelques paramètres à modifier)

Stéphane

[Pierre Fauconnier]

Wouah

Bravo Stéphane!

[Philippe Tulliez]

Magnifique Stéphane
Je n'ai pas encore approfondi les possibilités de LAMBDA, LET, SCAN, MAKEARRAY, ...
Merci pour la décomposition et les explications

[Raccourcix]

Merci de vos retours

comme promis j'ai légèrement modifié le fichier pour afficher les ensembles de Julia.
La formule est maintenant z_n+1=z_n²+c avec c un nombre imaginaire
J'ai ajouté des paramètres pour gérer les coordonnées + le pas + le seuil + cette constante c.

Toujours une fonction nommée, une formule MAKEARRAY + une mise en forme conditionnelle

Mes sources pour les calculs
http://sdz.tdct.org/sdz/dessiner-la-...andelbrot.html

Et l'article de Chandoo https://chandoo.org/wp/the-excel-mandelbrot/ qui traite le sujet avec des tables et des complexes.
cet article récent m'a rappelé mes premiers programmes en C++ ou turbo pascal dans les années 90. le temps de tracé était vraiment long !


dans cette vidéo j'ai utilisé c = 0.43 + (0 --> 0.6) i.
durée initiale 1'40" réduite à un peu plus de 10"



Et le fichier
2023_01_23 Julia.xlsx

Stéphane

[Philippe Tulliez]

Bonjour Stéphane, c'est du grand art

[jakboregar]

autrefois on avait la fonction EVALUATE, qui a été supprimée, à mon avis à cause des risques si import de feuille malveillante, il y avait un biais pour restaurer cette fonctionnalité.
je ne connaissais pas cette nouvelle fonction lambda (du coup je vais être obligé de réécrire beaucoup de code car j'utilisais la variable nommée "lambda" pour des applications scientifiques et j'ai remarqué que Excel peut buguer si on utilise un nom de variable utilisé comme nom de fonction)
et je vais la tester de ce pas, merci le forum
PS je suis impressionné par la programmation sur Mandelbrot !!!! bravo
d'ailleurs je vais m'attaquer au jeu de la vie

[Pierre Fauconnier]

Salut

autrefois on avait la fonction EVALUATE, qui a été supprimée...

Je ne me souviens pas de la fonction EVALUATE en Excel (peut-être une fonction XL4?). Par contre, elle existe toujours en VBA. Est-ce de cela dont tu parles?