Prise en main

Pour un apprentissage rapide je recommande cette lecture (tout est dans le titre) http://learnxinyminutes.com/docs/julia/

Fonctions scientifiques

Regardons les possibilités de calcul offert par cet environnement !

On est devant une superbe calculatrice comme dans la console de Matlab/Scilab ou R. On a donc l’utilisation des opérateurs classiques +-*/\^ ainsi que toutes les fonctions scientifiques sin, cos exp log

voir Mathematical Operations and Elementary Functions

A remarquer l’utilisation de la fonction log comme le logarithme naturel (Népérien).

log(100)

4.605170185988092

log10(100)

2.0

Fonctions usuelles
exp, log, log10, abs, sqrt, cbrt, sign

Fonctions trigonométriques usuelles
sin, cos, tan, cot, sec, csc, sinh, cosh, tanh, coth, sech, csch, asin, acos, atan
acot, asec, acsc, asinh, acosh, atanh, acoth, asech, acsch, sinc, cosc, atan2

Il est possible d’utiliser les notations scientifiques 1e2 pour 100, ainsi que quelques nombre prédéfinis pi, im …

1e-2

0.01

2pi^2

19.739208802178716

1im^2

-1 + 0im

Certaines fonctions possèdent un domaine de définition comme sqrt, log… sur \(I\!\!R\) extensible aux nombres complexes :

sqrt(complex(-1))

0.0 + 1.0im

L’ensemble des fonctions scientifiques est étendu au calcul complexe !

sin(1+im)

1.2984575814159773 + 0.6349639147847361im

Fonctions d’arrondi
round, floor, ceil, trunc

Julia possède une algèbre étendue avec la possibilité de divisé par 0

1/0

Inf

1/Inf

0.0

Inf+1

Inf

Inf/Inf

NaN

Inf-Inf

NaN

0*Inf

NaN

NaN+1

NaN

Inf et NaN représentant l’infini et Not A Number. Toutes les formes indéterminées donnant NaN et toute combinaison avec NaN renvoie également NaN. missing existe également avec un comportement similaire pour gérer les données manquantes mais attention, cela change le type de vos variables.

typeof(NaN)

Float64

typeof(missing)

Missing

Variables

L’utilisation de variable est très intuitive sans déclaration préalable de type (entier, réel, imaginaire, fraction rationnelle…). Le nom de la variable doit commencer par une lettre entre a-z ou A-Z mais aussi par un underscore (‘_’) ou encore un caractère Unicode (voir dernier exemple pour comprendre)

a = 1

1

typeof(a)

Int64

b = sqrt(2)

1.4142135623730951

typeof(b)

Float64

c = 9//12 + 4//7

37//28

typeof(c)

Rational{Int64}

c = a + b
typeof(c)

Float64

On voit dans ce qui précède que les variables sont typées, mais un mécanisme automatique de changement de type (comme Int64 \( \rightarrow\) Float64) permet la somme d’un entier et d’un réel. On peut demander à Julia d’identifier un entier comme un réel (Float) avec l’ajout d’un . exemple a=1..

Une particularité est de ne pas avoir la possibilité de supprimer une variable ! Il est juste possible de récupérer l’espace mémoire en faisant a=[].

 Float64 <: Real

true

a = []

Any[]

Toujours dans la rubrique particularité on verra que les fonctions sont aussi des variables, il sera donc possible de les passer en argument, de les affecter etc…

∑(x) = sum(x)

∑ (generic function with 1 method)

ρ¹=1

1

α = 2
β = 3

3

λ₁ = 42

42

L’utilisation de caractères spéciaux comme les lettres grecques se font par utilisation d’une syntaxe de type \(\LaTeX\). Pour écrire \(\rho\) par exemple, dans la plupart des éditeurs il faut commencer par \rho puis la touche TAB fait afficher le caractère

2π

6.283185307179586

ℯ     # \euler

ℯ = 2.7182818284590...

√2

1.4142135623730951

Convention et style

Julia impose quelques restrictions de nom de variable, de plus les conventions suivantes sont d’usage :

• Les noms des variables sont en minuscule.

• La séparation des mots dans une variable se fait à l’aide d’un underscore (‘_’) mais cette pratique n’est pas recommandé pour une question de lisibilité des noms de variable.

• Les noms de Type ou de Modules commencent par une lettre majuscule, les majuscules séparant les différents mots du nom de la variable (exemple “MonModule”)

• Les noms des fonctions et macros sont en minuscule sans underscores.

• Les fonctions qui modifient en sortie leurs arguments d’entrée s’écrivent avec ! à la fin.

Il existe différents styles possibles que vous pouvez retrouver dans la documentation de JuliaFormatter

Types de variable

Julia n’est pas à proprement parler un “langage objet” néanmoins c’est ce que l’on peut appeler un “langage typé”. En effet ce langage possède un certain nombre de types prédéfinis et permet d’en ajouter à volonté. Les nouveaux types faisant office de structure tel un objet (C++/Java…) permettant la surcharge des opérateurs standards *, /, +,....

Les nombres scalaires

On a vu précédemment que Julia est assez flexible sur l’utilisation et l’affectation des variables et est capable de rendre compatible l’addition d’entier, réel (float)…

De manière naturelle on trouve les types :

• Int8, UInt8, Int16, UInt16,Int32, UInt32, Int64, UInt64,Int128, UInt128.

• Float16 (simple précision i.e 8 chiffres significatifs), Float32 (double précision, 16 chiffres significatifs), Float64 (32 chiffres significatifs)

• ComplexF32, ComplexF64.

a=1000000000000; typeof(a)

Int64

a=10000000000000000000; typeof(a)

Int128

b=10;
println(typeof(b))
b=Int32(b)
println(typeof(b))

Int64
Int32

convert(Float64,b)
Float64(b)

10.0

c=1.0
println(typeof(c))

Float64

Il est possible de forcer le type d’une variable à l’aide des commandes Int8(), Int16()…Float32()…

Remarque : Opérations type unaire sur une variable

+=, -=, *=, /=, \=

a = 1
a += 1

2

a *= 3

6

Les booléens

Les variables booléennes (1bit) sont naturellement définies dans Julia à l’aide des opérateurs de comparaison

opération	égalité	différent	supérieur	supérieur ou égal	inférieur	inférieur ou égal
syntaxe	a==b	a!=b	a>b	a>=b	a<b	a<=b

a = 1>0  ;println(a)  ;typeof(a)

true

Bool

Avec les opérateurs de conjonctions

et	ou	not
&	|	!

!((a && true) && (a || false)) 

false

2>1 && 0>-1  

true

Les chaines de caractère

Julia possède un type Char (Charactere) il s’agit d’une lettre délimité par ‘’ à ne pas confondre avec la chaine de caractère.

z = 'a'

'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

z = z+1 # en ajoutant 1 on passe aux charactère suivant dans la table 

'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase)

La chaine de caractère est délimitée par “” et définit un type ASCIIString ou UTF8String

a = "Une chaine de caractère \n"  # \n est le retour à la ligne

"Une chaine de caractère \n"

typeof(a)

String

La concaténation de chaîne se fait par l’utilisation de * (multiplication)

b = a * "puis une autre..." 

"Une chaine de caractère \npuis une autre..."

println(b)  # \n renvoie à la ligne

Une chaine de caractère 
puis une autre...

b *= "puis une autre..."^2 # la puissance permet de répéter la chaine

"Une chaine de caractère \npuis une autre...puis une autre...puis une autre..."

Vous pouvez également utiliser la fonction string

string("Hello", "World")

"HelloWorld"

On peut extraire ou affecter une partie de cette chaîne considérée comme un tableau

a[1:10]

"Une chaine"

Warning

a[1] est de type Char

a[1]

'U': ASCII/Unicode U+0055 (category Lu: Letter, uppercase)

println(string(typeof(a[1]))*"\n")
println(string(typeof(a[1:1])))

Char

String

L’usage de $ permet comme en php de convertir et d’inclure une variable dans une chaîne de caractères (interpolation)

m = 11
a = "le mois de novembre est le $m ième mois "

"le mois de novembre est le 11 ième mois "

b = "racine de 2 : $(sqrt(2))"

"racine de 2 : 1.4142135623730951"

using Printf

@printf "La valeur de π est %15.10f" π

La valeur de π est    3.1415926536

Pour encore plus de possibilités avec les chaînes de caractère : https://docs.julialang.org/en/v1/manual/strings/#man-strings-1 et sur Printf