Discussion :

[Invité]

Bonjour,

Je suis en train d'apprendre le langage J. Pour ceux qui ne le connaissent pas, le J se veut le successeur d'APL. C'est un langage interprété (l'interpréteur est téléchargeable gratuitement chez www.jsoftware.com), destiné à effectuer des calculs sur des tableaux.

A la base, ca se présente donc comme une calculette géante, avec un grand nombre d'opérateurs de base. On a les 4 opérations, pour les nombres, les listes et les matrices, mais aussi des opérateurs "de base" pour les logarithmes, les puissances, les décompositions en facteurs premiers, l'inversion matricielle, les conversions d'une base à une autres, etc... Tous les opérateurs s'écrivent avec un ou deux caractères (diviser c'est %, racine carrée %:, inversion matricielle %. ...)

Les types de données gérés nativement incluent les réels, les fractions, les complexes, les chaines de caractères (sous forme de vecteurs, ou de matrices).

La principale force du langage est sa capacité à définir de nouveaux opérateurs sans jamais faire référence aux données qu'ils vont traiter. Ceci est fait par des règles complexes de composition d'opérateurs.

Par exemple, <. est la partie entière d'un nombre, = la comparaison, pour tester si un nombre est entier, on fera =<. (égal à sa partie entière).

%: est la racine carrée, +/ la somme de tous les éléments d'un vecteur, et *: le carré. On peut définir la norme d'un vecteur (quelle que soit sa taille) par %:+/*: (racine de la somme des carrés...)

Ces assemblages permettent d'exprimer très simplement des formules complexes : par exemple, le calcul des convergents d'une fraction continue s'exprime en (+%)/ (ajouter et prendre l'inverse pour chaque élément)...

Enfin, on dispose d'opérateurs gérant les différentes facettes de la composition de fonctions. Notamment un opérateur permettant la composition multiple, et même l'inversion d'une fonction. Par exemple p:1000 donne le 1000ième nombre premier, p:^:_1 1000 le plus petit nombre premier supérieur à 1000...

Au total ca donne un langage pas très facile d'abord, absolument déconseillé à ceux qui n'aiment pas la notation mathématique, mais très curieux et très puissant, et finalement assez intuitif une fois qu'on a "pigé le truc" (le truc étant que ca s'écrit comme ca se dit...)

Y'a-t-il ici d'autres pratiquants? Qu'on essaye d'échanger sur le sujet...

Francois

[BernardV]

Bonjour,
J'ai travaillé en APL de 81 à 86, c'est le langage qui m'a le plus plu. J'ai découvert J un peu par hasard, et je l'apprécie.
Etant maintenant à la retraite, je passe un peu de temps à l'apprendre (j'ai du temps). En ce moment, je me traduis quelques cours, c'est bon pour l'apprentissage du langage. Surtout qu'il n'existe pas encore de cours complet en français. Cela pourra servir à d'autres.
Je crois que l'on peut compter les informaticiens en J, sur les doigts d'une ou de deux mains, en France, mais je peux me tromper, je ne sais pas tout.
C'est cette originalité qui peut faire l'intérêt du langage, ainsi que sa rigueur, et sa puissance.
Je l'apprends pour essayer de faire quelque chose avec (je me fais des petites applis), mais pour travailler en équipe, ce n'est pas gagné vu le faible nombre de pratiquants.
@+
Bernard

[BernardV]

Faut montrer l'exemple :
Demander le 1000 ième nombre premier (0 étant 2; 1 étant 3; 2 étant 5; etc...)
p:1000
7927

Ca marche aussi pour plusieurs d'un coup (les 5 premiers nombres)
i.5
0 1 2 3 4

p: i.5
2 3 5 7 11

Demander le 1000 ième, 1001 ième, ...
1000 + i.5
1000 1001 1002 1003 1004

p: 1000 + i.5
7927 7933 7937 7949 7951

Et pour retrouver les positions de ces nombres premiers là :
(p: ^: _1)7927 7933 7937 7949 7951
1000 1001 1002 1003 1004

Bien sûr, si on fait de la gestion, on n’en a pas besoin. Mais si on n'aime pas les boucles on trouve forcément cela intéressant.

On peut aussi s’inscrire et suivre le forum :
http://www.jsoftware.com/forums.htm

Bernard

[Invité]

Allez, moi aussi j'y vais de mon tuto...

Quand on débute en J, ça ressemble à une calculatrice. On a les 4 opérations, + - * % (attention, diviser ce n'est pas /). On peut donc taper des choses comme

2+3+4
et ca répond
9

Une seconde particularité, c'est que J ne connait pas la précédence d'opérateur. Plus précisément, tous les calculs sont faits de la droite vers la gauche

2*3+4
est lu comme
2*(3+4)
et vaut donc 14

On peut bien sur ajouter des parenthèses, et écrire
(2*3)+4
et là on aura bien 10...

Cette absence de précédence peut sembler déroutante. Elle a deux raisons principales :

1- en J, il y a beaucoup d'opérateurs (et l'utilisateur peut en ajouter autant qu'il veut), mémoriser la précédence de chacun serait très difficile
2- en J, on utilise très peu de structures de controles (boucles, tests), les programmes sont séquentiels, il y a donc tout intérêt à avoir un ordre unique d'évaluation

Au delà des 4 opérations, J propose pas mal d'opérateurs tout faits. D'abord presque tous les opérateurs peuvent être unaires ou binaires (le contexte en décide). Pour les 4 opérations

+ binaire = addition 2+3=5
+ unaire = conjugué (sans effet pour un réel, conjugué pour un complexe)
- binaire : soustraction 3-1=1,
- unaire, opposé : -2= _2 (en J le signe moins s'écrit avec un underscore, pour ne pas confondre avec l'opérateur)
* binaire : multiplication, 3*2=6
* unaire : signe (_1 pour un négatif, 1 pour un positif), ou nombre divisé par son module pour un complexe (en J les complexes se notent avec un j entre la partie réelle et l'imaginaire : *3j4 = 0.6j0.8)
% binaire : division 3%2=1.5
% unaire : inverse %2=0.5

^ binaire, puissance : 2^3 = 8
^ unaire, exponentielle ^1=2.71828

^. binaire, logarithme de base quelconque 10^.100=2
^. unaire, logarithme népérien

%: binaire, racine n-ième : 3%:8 = 2
%: unaire, racine carrée %:2 = 1.4142

| unaire, module (valeur absolue pour un réel, norme pour un complexe)
| binaire, résidu modulo
! unaire, factorielle
! binaire, C(n,p) combinaisons
<. unaire, arrondi vers le bas
<. binaire, min de deux nombres
>. unaire arrondi vers le haut
>. binaire, max de deux nombres

*: unaire, carré
+: unaire, doublement
-: unaire division par 2

+. binaire : PGCD
*. binaire : PPCM

o. unaire : fois Pi (3.141592)
p: unaire, n-ieme nombre premier

Là où ca devient amusant, c'est que ces opérateurs fonctionnent aussi bien sur des nombres que sur des listes de nombres, par exemple

1 2 3 + 1 2 3 = 2 4 6
*: 1 2 3 = 1 4 9

Et avec les listes on a de nouveaux opérateurs, par exemple

p. unaire donne les racines d'un polynome :
p. 0 1 2 donne les racines de X+2X^2 : _0.5 0
p. binaire évalue un polynome en un (ou plusieurs points)
0 1 2 p. 0 1 = 0 3
q: unaire renvoie les facteurs premiers d'un entier

+/ unaire renvoie la somme des éléments d'un vecteur
# unaire renvoie leur nombre
# binaire, filtre une liste 1 0 1# 1 2 3 = 13

/: trie une liste en ordre croissant (en fait renvoie le tableau d'index correspondant)
\: trie en ordre décroissant

La puissance du système apparait quand on compose ces éléments, (et là des règles spécifiques apparaissent)

(%#) 1 2 3 = 123 % (#1 2 3) divise chaque terme par le nombre de terme de la suite
(+/%#) 1 2 3 est la moyenne, soit 2

La langage permet de renommer tous ces opérateurs par exemple en faisant

moyenne=: +/%#

on aura alors
moyenne 1 2 3 = 2

On peut également renommer les opérateurs standard, par exemple
racine=: %:

L'une des principales forces du langage, c'est cette capacité à définir des opérateurs par "composition" d'autres opérateurs.

Par exemple, la moyenne s'écrit +/%#
La variance (moyenne@:*: )-(*:@:moyenne)
La somme des inverses des carrés d'une suite +/%*:
La somme alternée des inverses des carrés -/%*:
Le produit des termes d'une suite */
Le calcul d'une fraction continue (+%)/
Les convergents (valeurs successives) d'une fraction continue (+%)/\

Cette définition implicite des opérateurs (sans faire référence aux données) permet au langage d'effectuer des calculs formels. Par exemple, J peut calculer la dérivée d'un opérateur, son intégrale, ou calculer la réciproque d'une fonction

p:1000 est le 1000 ième nombre premier
(p:^:_1) 1000 (^:_1 puissance moins un, = réciproque d'une fonction) 168 (le rang du plus petit nombre premier supérieur ou égal à 1000).

Allez, pour ceux qui aiment les maths, un dernier exemple. La fraction rationnelle x/ (1-x-x^2) peut être définie en J par (%-.-*: )

*: est le carré : *: x = x^2
-. x = 1-x
(-. - *: ) x = (1-x) - (x^2)
(%-. - *: ) x = x/ (1-x-x^2)

Observez la règle assez particulière de composition des opérateurs
(fg) x = x f g(x), et (fgh) x = f(x) g h(x)


Pourquoi cette fonction (et là j'espère qu'il y a des matheux dans la salle)? Parce que les termes de sa série de Taylor sont les valeurs de la suite de Fibonacci... et là, on va utiliser une nouvelle fonction t. qui donne les termes de la série de taylor

(%-.-*: ) t. 0 1 2 3 4 5 6 7 8 ... 20
ou
(%-.-*: ) t. i.20
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

Et là, bien sur, on pourrait en faire une fonction
fib=: ( (%-.-*: )t.@:i.)

ou rechercher le 1000ieme terme de la suite, (%-.-*: ) t. 1000, ce nombre de 209 chiffres sera écrit en précision infinie (J gère automatiquement les précisions de calcul aussi grandes qu'on veut). (NB dans ce cas précis, le passage à la série de Taylor n'est pas une bonne idée, le calcul prend une trentaine de secondes, la bonne solution, serait de calculer en précision infinie la partie entière d'une puissance du nombre d'or, là c'est presque instantané...)

En fait, t. ça produit une suite à partir de sa fonction génératrice...

Francois

[BernardV]

J'essaie autre chose.

La primitive racine carrée : « %: » (pourcent, deux points)

On la teste :
%: 2
1.41421

Ca marche aussi pour plusieurs nombres d’un coup !
%: 1 2 3 4 5
1 1.41421 1.73205 2 2.23607

On force avec des nombres négatifs !
%: _2 _1 0 1 2
0j1.41421 0j1 0 1 1.41421

Il n’a pas planté, il a trouvé les bons nombres complexes !

Faut vérifier avec la fonction, puissance inverse de fonction « ^:_1» soit ici (%: ^:_1) qui équivaut évidemment à « carré », ici en précision standard, avec ce qu'il nous a rendu :
(%: ^:_1) 0j1.41421 0j1 0 1 1.41421
_1.99999 _1 0 1 1.99999

On vérifie directement avec la primitive carré « *: » (étoile, deux points) :
*: 0j1.41421 0j1 0 1 1.41421
_1.99999 _1 0 1 1.99999

On peut écrire une fonction racine :
racine=: %:

On l’essaie :
racine 2
1.41421

racine 1 2 3 4 5
1 1.41421 1.73205 2 2.23607

racine _2 _1 0 1 2
0j1.41421 0j1 0 1 1.41421

(racine ^: _1) 0j1.41421 0j1 0 1 1.41421
_1.99999 _1 0 1 1.99999

On devrait enseigner ça à l'école!

Bernard

[Invité]

En J, on peut écrire des fonctions presque comme dans les langages qu'on aimait avant...

Par exemple, on pourrait définir la somme des inverses des n premiers nombres (1+1/2+1/3+1/4 ....)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
NB. ceci est un commentaire
harm =: 3 : 0 NB. ceci est la définition d'une fonction
   n=.0
   res=.0
   NB. y est le paramètre de la fonction
   while. n<y do.   
      n=.n+1
      res=.res+1%n
   end.
  NB. valeur de retour
  res
) NB. fin de fonction

et là, si on tape

harm 10
2.9289
et pour le calcul exact, on met x: (précision infinie) devant
x: harm 10
7381r2520 (7381/2520)

et de même
harm 1000000
14.3927

et NB. ^. = logarithme népérien...
(harm 1000000) - (^.1000000)
0.577216

Mais la boucle n'est pas réellement nécessaire... En J, on a pour les suites une primitive : i.n qui renvoie la suite des nombres de 0 à n-1

i.3 = 0 1 2
1+i.3 = 1 2 3
et comme % inverse les nombres
% 1+i.3 = 1/1 1/2 1/3
il ne reste qu'à sommer tout cela avec +/
+/ % 1+i.3 = 1.83333

et là
+/ % 1+i.1000000 = 14.3927
mais le calcul est nettement plus rapide

i. permet des choses amusantes :

+/ i.n : somme des nombres de 0 à n-1
+/ 2+i.n : somme des nombres de 2 à n+1
+/ 3*1+i.n : somme des multiples de 3, de 3 à 3n
(i.n = 0 1 2 ... n-1, 1+i.n = 1 2 3 ... n, 3*1+i.n = 3 6 9 12 ... 3n)

+/ *:% 1+i.n somme des inverses des n premiers carrés (1+1/4+1/9...)

Des "boucles" plus complexes peuvent être effectuées grace à l'opérateur #. Le # unaire compte les éléments d'une liste :
# 1 2 4 5 = 4
Le # binaire permet de sélectionner des éléments dans une liste
1 0 0 1 # 1 2 3 4 = 1 4
On peut alors mettre une condition sur les éléments de cette liste :
(1 2 3 4 >2 ) # 1 2 3 4 = 0 0 1 1 # 1 2 3 4 = 3 4
De façon plus compacte, ceci peut s'écrire
(#~>&2) 1 2 3 4
>&2 est la comparaison à 2 (& est un opérateur de binding, parfois appelé Curry, qui fixe l'une des valeurs d'un opérateur binaire)
#~ applique la condition qui suit aux membres du vecteur, ie renvoie les membres qui la vérifient.

Si on se rappelle que | désigne le reste de la division de deux nombres, "être divisible par 7" s'écrit (0=7&|)
Et la liste des multiples de 7 compris entre 100 et 120 s'écrirait

(#~0=7&|) 100+i.20 = 105 112 119
(et bien sur, si on voulait les sommer, on écrirait +/ devant...)

La somme des carrés inférieurs à 1000 serait :
+/ (#~1000&>) *:i.100
et celle des carrés de nombres inférieurs à 100 divisibles par 12
+/ (#~0=12&|) *:i.100

Enfin, J fournit un opérateur ^: permettant d'itérer une fonction ( f(f(f(x)))... )

*: est le carré *: 2 = 4
(*:^:2) élève au carré deux fois de suite (*:^:2) 2 = 16

Au final, on réalise que les boucles, en fait, ce n'est pas très nécessaire, pour programmer...

Francois

[BernardV]

Je cherche à montrer un exemple pratique et simple qui peut servir. On peut sans doute trouver mieux, ou le faire plus efficacement. Mais, je veux ici montrer l’intérêt du langage.

Je cherche à suivre la consommation de ma voiture au fil des kilomètres parcourus.J’ai noté mes pleins (presque pleins) et mes kilomètres, 14 fois de suite, sur 8469 kilomètres.

Je rentre mes données par des « affectations » (primitive ou signes : égal, 2 points).

KmSaisis =: 30730 31528 32116 32868 33488 34079 34644 35199 35875 36495 36990 37583 38361 39199

PompeSaisis =: 43.15 52.28 32.02 52.78 49.65 46.03 46.12 57 51.06 53.62 35.01 44.24 47.46 52.82

Je vérifie que j’en ai bien 14 (par la primitive monadique « compte », signe : dièse).
#KmSaisis
14
#PompeSaisis
14

Le premier plein ne me sert pas, je le laisse tomber (primitive dyadique « tombe », signes : 1, accolade fermante).
PompeIntervalles =: 1}. PompeSaisis

Je vérifie…
PompeIntervalles
52.28 32.02 52.78 49.65 46.03 46.12 57 51.06 53.62 35.01 44.24 47.46 52.82

Je vérifie que j’en ai bien 13…
# PompeIntervalles
13

Je veux connaître les intervalles des kms. A mon vecteur (ou liste) des kms, je concatène un zéro, en fin, j’obtiens un premier vecteur. Puis je concatène un zéro en début de mon vecteur des kms, j’obtiens un second vecteur. Puis, je soustrais le second vecteur du premier. Il y a d’autres moyens.

(KmSaisis,0) -0,KmSaisis
30730 798 588 752 620 591 565 555 676 620 495 593 778 838 _39199

Je laisser tomber, le dernier élément (primitive dyadique « tombe », signes : _1, accolade fermante), et le premier élément qui ne veulent rien dire.
KmIntervalles =: 1}. _1 }. (KmSaisis,0) -0,KmSaisis

Je vérifie que j’obtiens bien les intervalles entre mes kms.
KmIntervalles
798 588 752 620 591 565 555 676 620 495 593 778 838

Je vérifie que j’en ai bien 13.
#KmIntervalles
13

Je peux calculer la consommation entre chaque plein (avec les primitives dyadique * « multiplié », signe étoile, et la primitive dyadique % « divisé », signe pourcent). La division s’entend ici élément par élément. Le scalaire 100 est étendu lors de la multiplication à la dimension du vecteur, argument droit.
ConsoIntervalles=:100*PompeIntervalles %KmIntervalles

Soit :
ConsoIntervalles
6.55138 5.44558 7.01862 8.00806 7.78849 8.16283 10.2703 7.55325 8.64839 7.07273 7.46037 6.10026 6.3031

Je peux calculer aussi la consommation moyenne, sur mon kilométrage total, soit entre le premier plein (0{KmSaisis) et le dernier plein (_1{KmSaisis) par la primitive dyadique « prend » { accolade ouvrante.

KmTotal =: (_1{KmSaisis)- 0{KmSaisis

Je vérifie
KmTotal
8469

ConsoMoyenne =: 100*(+/ PompeIntervalles) % KmTotal

ConsoMoyenne
7.32188

Je veux en faire un graphique. Je choisi la librairie ‘plot’ qui permet de tracer une courbe. Je donne des repères sur l’axe des x, et les hauteurs correspondantes sur l’axe des y. Plot relie ces points par un trait. Je choisi de placer un point pour chaque kilomètre.

La primitive « iota » ou « entier » i. me donne ici les entiers de 0 à KmTotal, J’ajoute à chacun des éléments de ce vecteur, le premier km réellement parcouru.

AxeX =: 1 + (0{KmSaisis) + i. KmTotal

Je vérifie ce que cela donne
AxeX
30731 30732 30733 30734 etc…

J’aurais donc 8469 points.
#AxeX
8469

Pour trouver 8469 ordonnées, j’utilise la primitive dyadique # « fois » . Elle place chaque élément du second vecteur autant de fois que l’indique chaque élément correspondant du premier.
AxeY1 =: KmIntervalles # ConsoIntervalles

Je vérifie …

AxeY1
6.55138 6.55138 6.55138 etc…..

#AxeY1
8469

Je vais aussi tracer aussi la moyenne de la même façon.
AxeY2 =: KmTotal # ConsoMoyenne
AxeY2
7.32188 7.32188 7.32188 etc …
# AxeY2
8469

J’appelle ma librairie
load 'plot'

J’efface mes essais précédents éventuels.
pd 'reset'

Je trace mes courbes.
pd AxeX;AxeY1
pd AxeX;AxeY2

J’ajoute mes titres
pd 'key "Entre chaque plein","Moyenne"'
pd 'title Consommation'

et, j’affiche
pd 'show'

Je sauvegarde l’image du graphique, que j’affiche ici
pd 'save JPG'
ou
pd 'save bmp'

C’est tout, c’est simple, sans boucle.

Bernard

[Invité]

En J, les nombres en précision infinie et les rationnels font partie du langage...

Cherchons à calculer la racine de 2... Une première approche consiste à écrire

%: 2
1.41421

on peut améliorer la précision en écrivant

x: %: 2 NB. x: calcul précis
431273813145r304956637823

on a ainsi une approximation rationnelle
431273813145/304956637823

que l'on peut écrire en décimal avec le préfixe 0j100 ": (": est le verbe "format", 0j100 précise le format, ici 100 décimales). Ici, les 16 premières décimales sont correctes..
0j100 ": 431273813145r304956637823
1.4142135623731390970412181031989721904863670411925480575736180767789366814500092718645843712378263880

Pour aller plus loin, on peut utiliser la fraction continue
sqrt(2)=1+1/(2+1/(2+1/(2+1/.....)))))

En J, cela va s'écrire

0j100":_1+(+%)/x: 100#2
1.4142135623730950488016887242096980785696718753769480731766797379907324784621858173900502314551910537

(100#2 produit une liste recopiant 100 fois le nombre 2)

les 75 premières décimales sont correctes, mais avec
_1+(+%)/x: 1000#2
on aurait plusieurs centaines de décimales.

L'un des intérêts des fractions continues est qu'elles donnent les "meilleures" approximations de la racine par des rationnels. POur ce faire, on peut utiliser l'opérateur \ (scan) qui donne les termes successif du calcul précédent

_1+(+%)/ \x: 10#2
1 3r2 7r5 17r12 41r29 99r70 239r169 577r408 1393r985 3363r2378

On voit ainsi que de bonnes approximations de la racine de 2 sont 99/70 (4 décimales correctes avec un dénominateur inférieur à 100), 3363/2378 (8 décimales)


Une autre approche est l'application de la formule de Newton. Pour celle ci, on part de x=1; et on calcule x/2+1/x et on répète le calcul...

L'avantage de ce calcul est qu'il est quadratique, le nombre de décimales correctes double à chaque itération...

En J, x/2+1/x s'écrit
(-:+%)

Cette opérateur est appelée une "fourche" (fork), il est obtenu par concaténation de 3 opérateurs -: qui divise son opérande par 2, + qui ajoute ses opérandes, et % qui prend l'inverse de son opérande.

En J, une fourche (fgh) x s'évalue comme (fx) g (hx), ici

(-:+%) x = x/2+1/x juste ce qu'il nous faut...

Pour itérer un opérateur, on dispose d'une commande ^: (f^:2) x = f(f(x))

Donc ici, on va calculer

((-:+%)^:10) 1

3 itérations donnent 5 décimales
((-:+%)^:3) 1
1.41421356237
4 itérations en donnent 11
((-:+%)^:4) 1
1.41421356237468991
8 itérations en donnent plus de 100, 10 plus de 500.

Le calcul est aussi nettement plus rapide.


D'autres constantes peuvent ainsi être calculées, par exemple e, la base des exponentielles, pour lesquelles on a la jolie fraction continue

e= 2+ 1 / (1+ 1/(2+2/(3+3/...)))

en J, ceci s'écrirait (les calculs se font de la droite vers la gauche

2+% 1+1%2+2%3+3%...

on peut générer la série
1 1 2 2 3 3 4 4 5 5 = 2#i.5
et insérer alternativement des + et des % entre ses termes avec la commande (+`%)/
0j100 ": 2+% (+`%)/ 2#i.100x
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785251664274

Il y a environ 65 décimales correctes

Mais on peut également utiliser la célèbre série

e=2+1/2!+1/3!+1/4!...

En J, les nombres de 1 à 100 s'écrivent 1+i.100x
leurs factorielles !1+i.100x
les inverses de leurs factorielles
%!1+i.100x
et la somme plus 1
1+ +/%!1+i.100x
2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785251664274

Francois