Marching methods

7 avril 2007
maths lecture marching-methods

Poursuite du livre de Sethian

Deux méthodes pour suivre un front (d'onde, de fluide etc), connaissant sa vitesse normale, F, de propagation : l'une basée sur la valeur initiale (valable quelque soit F) et une autre sur les conditions aux limites (valable pour F>0).

Poursuite du livre de Sethian

On introduit plus formellement l'expression du problème et ses équations principales. On parle alors de métrique, de variation des oscillations en intégrant sur l'ensemble du front pour un t donné, de courbature etc. On aborde également la notion "d'entropie", que Sethian utilise et qui a du sens, même si ça n'est pas le même qu'en thermo ou en physique stat. On voit pour la première fois les effets d'un avancement du temps et les éventuelles pertes d'information que cela entraîne : comment intégrer ça dans la résolution d'une équation ? Une équation importante est la (2.16) qu'il faut redémontrer facilement.

Chapitre 3

Honnêtement je ne vois pas la pertinence de ce chapitre, non pas qu'il soit inutile, mais je ne le suis pas. C'est à relire car il est sûrement très intéressant pour la suite. Pour l'instant j'hypothèque...

Géométrie en 4 dimensions

7 avril 2007
maths lecture 4d

Tout part d'une constatation évidente sur la construction d'un cube à partir de deux simples points 1D :

(-1), (1)

Pour passer à un carré (2D) et enfin au cube (3D) il suffit de réaliser deux produits tensoriel avec le vecteur (-1, 1) :

(-1, -1) (1, -1)
(-1, 1) (1, 1)
Un carré
(-1, -1, -1) (1, -1, -1)
(-1, 1, -1) (1, 1, -1)
(-1, -1, 1) (1, -1, 1)
(-1, 1, 1) (1, 1, 1)
Un cube

Et en suivant la même logique on arrive à un objet à 16 points 4D, un hypercube :

(-1, -1, -1, -1) (1, -1, -1, -1)
(-1, 1, -1, -1) (1, 1, -1, -1)
(-1, -1, 1, -1) (1, -1, 1, -1)
(-1, 1, 1, -1) (1, 1, 1, -1)
(-1, -1, -1, 1) (1, -1, -1, 1)
(-1, 1, -1, 1) (1, 1, -1, 1)
(-1, -1, 1, 1) (1, -1, 1, 1)
(-1, 1, 1, 1) (1, 1, 1, 1)

Le but est maintenant de trouver comment projeter ces 16 points 4D en 3 dimensions pour le rendre sur un simple écran.

Lien 1 Lien 2 Lien 3

LUA

7 avril 2007
lecture lua learning

Programmation LUA

Mes débuts en Ruby

7 avril 2007
lecture

Programmation Ruby

puts pour afficher quelque chose en output, un nombre, une expression arithmétique, une chaîne de caractères etc.

L'opérateur de concaténation de chaîne est '+', mais l'opérateur '*' fonctionne. Par exemple :

puts 1+2*3/7.5
puts "exemple"
puts 'Chaîne '+'concaténée '*2
1.8
exemple
Chaîne concaténée concaténée
Bien faire attention au retour de l'opérateur '*' sur la chaîne

Les variables doivent commencer par une lettre minuscules. Les conversions de types simples sont faisables avec des fonctions du genre : to_s (to string) et to_i (to integer).

name = "flubb"  #Assignement, name commence par une minuscule
age="32"        #C\'est un nombre mais je le stocke en tant que chaîne pour illustrer les conversion
puts "Je m\'appelle "+name+", et dans "+age+" années, j\'aurai : "+(age.to_i*2).to_s+" ans."
puts age+"/5 (en entier) = "+(age.to_i/5).to_s
puts age+"/5 (en flottant) = "+(age.to_f/5).to_s
Je m'appelle flubb, et dans 32 années, j'aurai : 64 ans.
32/5 (en entier) = 6
32/5 (en flottant) = 6.4

A retenir : puts signifie 'put string', donc à chaque appel puts something, Ruby exécute 'put something.to_s'.

Gets et chomp : deux méthodes pour attendre la saisie d'une chaîne de la part de l'utilisateur (gets) et pour supprimer le retour à la ligne final (l'appui sur entrée).

puts "Entrez votre nom :"
name=gets
puts "Votre nom : "+name+"."
puts "Votre nom chompé : "+name.chomp+"."
puts "Entrez votre age :"
age = gets.chomp
puts "Vous avez "+age+" ans."   #Pas besoin de faire age.to_s
Entrez votre nom :
Flubb
Votre nom : Flubb
.
Votre nom chompé : Flubb.
Entrez votre age :
56
Vous avez 56 ans.

Les 'objets' puts, gets, chomp, to_s, to_i et to_f sont des méthodes, mais les opérateurs arithmétiques +, -, * et / le sont également (appliqués à des nombres le plus souvent). puts, gets et chomp sont des méthodes de l'objet 'self', le programme qui s'exécute. Apparemment puts est protégée...

age=32
str="Mon age : "+age.to_s
puts str
self.puts str
Mon age : 32
1:4: private method `puts' called for main:Object (NoMethodError)

D'autres méthodes de string à présent, length et reverse :

str1="J'apprend à programmer en Ruby"
puts "La chaîne <"+str1+"> fait "+str1.length.to_s+" caractères."
puts "Et à l'envers :"
puts str1.reverse
puts "ça fait toujours "+str1.reverse.length.to_s+" caractères."
La chaîne <J'apprend à programmer en Ruby> fait 31 caractères.
Et à l'envers :
ybuR ne remmargorp
Noter les problèmes d'encodage...

Des méthodes de string pour le formatage de l'affichage :

str1="j'apprend à programmer en RUBY"
puts "Chaîne de test : <"+str1+">"
puts "upcase : "+str1.upcase
puts "downcase : "+str1.downcase
puts "capitalize : "+str1.capitalize    #Capitalise le premier caractère
puts "swapcase : "+str1.swapcase
Chaîne de test : <j'apprend à programmer en RUBY>
upcase : J'APPREND à PROGRAMMER EN RUBY
downcase : j'apprend à programmer en ruby
capitalize : J'apprend à programmer en ruby
swapcase : J'APPREND à PROGRAMMER EN ruby

Et maintenant center.(%nbColumns%), ljust.(%nbColumns%) et rjust.(%nbColumns%), pour le formatage, avec une précision sur la passage de paramètres :

str1="j'apprend à programmer en RUBY"
puts "Chaîne de test : <"+str1+">"
puts str1.center(80)
puts str1.center 80         #Même résultat que la ligne précédente mais avec un warning
puts str1.ljust(80)
puts str1.rjust(80)
puts str1.ljust(40)+str1.rjust(40)
1:4: warning: parenthesize argument(s) for future version
Chaîne de test : <j'apprend à programmer en RUBY>
                       j'apprend à programmer en RUBY
                       j'apprend à programmer en RUBY
j'apprend à programmer en RUBY
                                                 j'apprend à programmer en RUBY
j'apprend à programmer en RUBY                  j'apprend à programmer en RUBY
Bien noter le warning suite au passage de paramètre sans parenthèses

Quelques autres exemples sur les nombres aléatoires, les valeurs absolues et l'objet Math (le premier objet que l'on utilise en en ayant conscience) :

#Exemples sur les RNGs
srand                   #Seed = temps courant de l'ordinateur
puts rand(101)          #Pour avoir un nombre entre 0 et 100
srand(1812)             #La seed est fixée
puts rand(101)          #Le nombre sera toujours le même : 91
srand                   #Seed = temps courant de l'ordinateur
puts rand(101)          #Pour avoir un nombre entre 0 et 100

#L'objet Math
puts "Pi = "+Math::PI.to_s
puts "e = "+(Math::E).to_s
MonCosinus=Math.cos(2*Math::PI/3)
puts "cos(2PI/3) = "+MonCosinus.to_s
puts "Valeur absolue du cosinus précédent : "+MonCosinus.abs.to_s
puts "Le nombre d'or : "+((1+Math.sqrt(5))/2).to_s
4
91
26
Pi = 3.14159265358979
e = 2.71828182845905
cos(2PI/3) = -0.5
Valeur absolue du cosinus précédent : 0.5
Le nombre d'or : 1.61803398874989

Les test : les opérateurs sont les mêmes que ceux de PHP (sans le triple égal) et C++, true et false sont des objets (true.to_s renvoie "true")

Après les tests : le if...else...end, note : pas de blocs d'exécution pour l'instant, pas d'accolades etc.

Boucle while %test%...end

command=""
puts "Entrez une commande ou "bye" pour quitter :"
while command!="bye"
    if command.length!=0
        puts command
    end
    command=gets.chomp
end
puts "Kassos"', "Programme qui attend une commande et la répète, jusqu'à ce qu'on rentre 'bye'.

Les tableaux :

[]
[5]
['Hello', 'Goodbye']
[89.9, flavor, [true, false]]

Parcours connu :

names = ['Ada', 'Belle', 'Chris']
puts names
puts names[0]
puts names[1]
puts names[2]
puts names[3]  #  This is out of range. >> objet nil !!!

Parcours automatique (while + méthode Array::length) :

names = ['Ada', 'Belle', 'Chris']
puts names
i = 0
while i <= names.length
    puts names[i]
    i = i+1     #Je ne connais pas encore l'opérateur ++
end

Each :

users = []
users.each do |user|
    puts "utilisateur "+user+" enregistré !"
end

équivalence des do...end et des blocs d'accolades {...}

parler des hash

parler du 3.times do...end

parler du Array::join, très pratique.

Retour d'une fonction : implicite (dernière ligne d'une fonction) ou explicite (return)

Programme implémentant et illustrant le bubble sort en ajoutant des méthodes à la classe Array :

class   Array
    #�change de deux éléments contigus du tableau
    def     swapSlot(i) self[i], self[i+1] = self[i+1], self[i] end
    #Raccourci, pour diminuer la taille de la méthode bubbleSort
    def     dc(i) self[i].downcase end
    def     bubbleSort comp
            i=0
            while (i<self.length-1)
                    if ((self.dc(i) <=> self.dc(i+1)) == comp and self.swapSlot i) i=0
                    else    i=i+1   end
            end
            self
    end
end

puts [ "jill", "norbert", "françois", "toto", "alphonse", "ZORRO", "JM", "Gilles" ].bubbleSort(1)
atoms=["zéro", "un", "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf", "dix", "onze", "douze", "treize", "quatorze", "quinze", "seize", "dix-dept", "dix-huit", "dix-neuf"]
dizaines=["", "dix", "vingt", "trente", "quarante", "cinquante", "soixante", "soixante-dix", "quatre-vingt", "quatre-vingt dix"]

while ((nb=gets.chomp) != "bye")
    if (nb.to_i<10)
            puts atoms[nb.to_i]
    else
            Rang2=nb.to_i/10
            Rang1=nb.to_i%10
            FrenchFlag=dizaines[Rang2][dizaines[Rang2].length-3, 3]=="dix"
            puts "FrenchFlag : "+FrenchFlag.to_s
            Output = ""
            if (FrenchFlag)
                    if (Rang2>1)
                            Output=dizaines[Rang2-1]
                    end
                    #Output=Output+atomsEx[Rang1]
                    Rang1=Rang1+10
            else
                    Output=dizaines[Rang2]
            end
            if (Rang2 > 1)
                    if (Rang1 == 1)
                            Output = Output+" et"
                    end
                    if (Rang1 >=1)
                            Output = Output+" "+atoms[Rang1]
                    end
            else
                    Output=atoms[Rang1]
            end
            puts Output
            puts "Dizaine : "+dizaines[nb.to_i/10]+", unités : "+atoms[nb.to_i%10]
    end
end
C'est limite du pseudo-code, arranger ça...

Le language MathML

6 avril 2007
server maths lecture
Essayer de trouver une syntaxe simple pour représenter graphiquement des formules à partir de code du genre :

    dx(sup(n)sub(i))/ds=~=(x(sup(n)sub(i+1))-x(sup(n)sub(i-1)))/2delta()s
    dy(sup(n)sub(i))/ds=~=(y(sup(n)sub(i+1))-y(sup(n)sub(i-1)))/2delta()s
    d(sup(2))x(sup(n)sub(i+1))/ds(sup(2))=~=(x(sup(n)sub(i+1))-2x(sub(i)sup(n))+x(sup(n)sub(i-1)))/delta()s(sup(2))
    d(sup(2))y(sup(n)sub(i+1))/ds(sup(2))=~=(y(sup(n)sub(i+1))-2y(sub(i)sup(n))+y(sup(n)sub(i-1)))/delta()s(sup(2))

Les parenthèses représentent des sous-blocs à rendre relativement à un bloc parent
Une double parenthèse (un bloc lui-même entre parenthèses) affiche des parenthèses
Des fonctions pré-existantes (built-ins) pour des opérations de base :
sup(%bloc%) : bloc en exposant
sub(%bloc%) : bloc en indice
delta() : signe delta minuscule
Delta() : signe delta majuscule
=~= : pour le signe "presque égal"
Accueil1 2