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 classique +-*/\^ ainsi que toutes les fonctions scientifiques sin, cos exp log (attention ici logarithme népérien)....

voir https://docs.julialang.org/en/v1/manual/mathematical-operations/

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


In [1]:
log(100)


Out[1]:
4.605170185988092

In [2]:
log10(100)


Out[2]:
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, e, im ...


In [3]:
1e-2


Out[3]:
0.01

In [4]:
2*pi


Out[4]:
6.283185307179586

In [5]:
im^2


Out[5]:
-1 + 0im

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


In [6]:
sqrt(-1)


DomainError with -1.0:
sqrt will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).

Stacktrace:
 [1] throw_complex_domainerror(::Symbol, ::Float64) at ./math.jl:31
 [2] sqrt at ./math.jl:492 [inlined]
 [3] sqrt(::Int64) at ./math.jl:518
 [4] top-level scope at In[6]:1

In [7]:
sqrt(complex(-1))


Out[7]:
0.0 + 1.0im

L'ensemble des fonctions scientifique est étendu au calcul complexe !


In [8]:
sin(1+im)


Out[8]:
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


In [9]:
1/0


Out[9]:
Inf

In [10]:
1/Inf


Out[10]:
0.0

In [11]:
Inf+1


Out[11]:
Inf

In [12]:
Inf/Inf


Out[12]:
NaN

In [13]:
Inf-Inf


Out[13]:
NaN

In [14]:
0*Inf


Out[14]:
NaN

In [15]:
NaN+1


Out[15]:
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.

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)


In [16]:
a=1


Out[16]:
1

In [17]:
typeof(a)


Out[17]:
Int64

In [18]:
b=sqrt(2)


Out[18]:
1.4142135623730951

In [19]:
typeof(b)


Out[19]:
Float64

In [20]:
c=9//12


Out[20]:
3//4

In [21]:
typeof(c)


Out[21]:
Rational{Int64}

In [22]:
c=a+b;
typeof(c)


Out[22]:
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=[].


In [23]:
a=[]


Out[23]:
0-element Array{Any,1}

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...


In [24]:
ρ¹=1


Out[24]:
1

L'utilisation de caractères spétiaux comme les lettres grecques se font par utilisation d'une syntaxe de type LaTex. Dans la Plupart des éditeurs il faut commencer par \rho puis la touche TAB fait afficher le charactère

Convention et style

Julia impose quelques restriction 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 ! en fin.

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 à volonter. Les nouveaux types faisant office de structure tel un objet (C++/Java...) permettant la surcharge des opérateurs standarts *, /, + ....

Les nombres scalaires

On a vu précédemment que JULIA est assez flexible sur l'utilisation et affectation des variable et est capable de rendre compatible l'addition d'entier, réel (float)...

De manière naturel 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)
  • complex32, complex64, complex128.

In [25]:
a=1000000000000; typeof(a)


Out[25]:
Int64

In [26]:
a=10000000000000000000; typeof(a)


Out[26]:
Int128

In [27]:
b=10;
println(typeof(b))
b=Int32(b)
println(typeof(b))


Int64
Int32

In [28]:
convert(Float64,b)
Float64(b)


Out[28]:
10.0

In [29]:
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étations type unaire sur une variable

| opération | += | -= | *= | /= | \= | |------|------|------|------|------|------|


In [30]:
a=1
a+=1


Out[30]:
2

In [31]:
a*=3


Out[31]:
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

In [32]:
a = 1>0  ;println(a)  ;typeof(a)


true
Out[32]:
Bool

Avec les opérateurs de conjonctions

et ou not
& | !

In [33]:
!((a&true) & (a|false))


Out[33]:
false

In [34]:
2>1 & 0>-1


Out[34]:
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.


In [35]:
z='a'


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

In [36]:
z=z+1 # en ajoutant 1 on passe aux charactère suivant dans la table


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

La chaine de caractère est délimitée par "" et définit unt type ASCIIString ou UTF8String


In [37]:
a="Une chaine de caractère \n"  # \n est le retour à la ligne


Out[37]:
"Une chaine de caractère \n"

In [38]:
typeof(a)


Out[38]:
String

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


In [39]:
b= a * "puis une autre..."


Out[39]:
"Une chaine de caractère \npuis une autre..."

In [40]:
println(b)  # \n renvoie à la ligne


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

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


In [41]:
a[1:10]


Out[41]:
"Une chaine"

ATTENTION


In [42]:
a[1] # le résultat est de type Char


Out[42]:
'U': ASCII/Unicode U+0055 (category Lu: Letter, uppercase)

In [43]:
a[1:1]


Out[43]:
"U"

In [44]:
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ère (interpolation)


In [45]:
m=11;
a="le mois de novembre est le $m ième mois "


Out[45]:
"le mois de novembre est le 11 ième mois "

In [46]:
b="racine de 2 : $(sqrt(2))"


Out[46]:
"racine de 2 : 1.4142135623730951"

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