Calcul scientifique
L'objectif est, sur base d'exemples concrets et réalistes, d'introduire puis d'illustrer les méthodes de calcul numérique nécessaires à la résolution de ces problèmes scientifiques.
Le langage principal qui sera utilisé ici sera avec ses extensions numpy et scipy et ipython, mais octave sera aussi illustré.
L'objectif étant de montrer que ces outils conviennent très bien pour remplacer le langage propriétaire Matlab — notons aussi l'existence du logiciel libre Scilab, ayant une syntaxe proche de Matlab.
Ce livre est bien sûr très lié à d'autre wikilivres, notamment plusieurs qui concernent les outils qui seront utilisés, tels que Octave et Matlab, abordés dans les livres le livre d'initiation Programmation Octave ou abordé dans le livre Programmation Python.
Toute aide et contribution sera la bienvenue.

Xml
Soya
Soya est un moteur 3D codé en python par jiba, ou Jean-baptiste Lamy. Ce tutoriel est une suite de codes source abondamment commentés et expliquant précisément à quoi sert chaque fonction. 
Ceci est un traduction approximative de la documentation officielle présente ici .

Soya/Python base 1
import sys, os, os.path, soya
soya.init()
soya.path.append(os.path.join(os.path.dirname(sys.argv[0]), "data"))
scene = soya.World()
sword_model = soya.Model.get("sword")
sword = soya.Body(scene, sword_model)
sword.x = 1.0
sword.rotate_y(90.0)
light = soya.Light(scene)
light.set_xyz(0.5, 0.0, 2.0)
camera = soya.Camera(scene)
camera.z = 2.0
soya.set_root_widget(camera)
soya.MainLoop(scene).main_loop()

Soya/Python base 2
import sys, os, os.path, soya
soya.init()
soya.path.append(os.path.join(os.path.dirname(sys.argv[0]), "data"))
scene = soya.World()
sword_model = soya.Model.get("sword")
class RotatingBody(soya.Body):
 # La classe principale appelle répétitivement la méthode advance_time pour tous les objets dans la scène.
 # Pour tourner un Body, nous avons juste à modifier cette méthode.
 # Dans Soya, l'unité de temps est le "Round", un Round équivaut à 30 millisecondes (par défaut).
 # Donc l'argument de advance_time est la proportion de temps dans un round ce qui produit :
 # par exemple, 0.3 fait que 30% d'un Round s'est passé entre 2appels soit 9 millisecondes.
 # advance_time doit être limité pour l'animation de code mais pas pour le code de décision. Nous verrons 
 # d'autres méthodes pour ça dans Base 3.
 def advance_time(self, proportion):
 # Appel de advance_time. Ceci est indispensable, comme tous les objets de Soya
 # que nous avons déjà dans la méthode advance_time.
 soya.Body.advance_time(self, proportion)
 # Tourner un objet sur l'axe Y. L'angle est proportionnel car
 # le plus gros du temps a été épuisé, nous voulons tourner dans l'ordre du lissage de l'animation. 
 # Presque toutes les rotations ou les mouvements se produisent dans advance_time qui a besoin
 # d'être proportionnel.[1]
 self.rotate_y(proportion * 5.0)
sword = RotatingBody(scene, sword_model)
light = soya.Light(scene)
light.set_xyz(0.5, 0.0, 2.0)
camera = soya.Camera(scene)
camera.z = 3.0
soya.set_root_widget(camera)
soya.MainLoop(scene).main_loop()
[1]
 # Rotates the object around Y axis. The angle is proportional to proportion because
 # the more time has been spent, the more we want to rotate, in order to achieve a
 # smooth animation.
 # Almost every rotations or moves that occurs in advance_time should be proportional
 # to proportion.

Soya python base 1
Soya python base 2
Variable
Soya/Python base 3
import sys, os, os.path, random, soya
soya.init()
soya.path.append(os.path.join(os.path.dirname(sys.argv[0]), "data"))
scene = soya.World()
class Head(soya.Body):
 # Voyons le constructeur de la classe.
 def __init__(self, parent):
 # Appel du constructeur soya.Body (rappelez vous, l'appel de cette super implémentation
 # est toujours une bonne idée), et utilisation du modèle appelé, 'caterpillar_head'.
 soya.Body.__init__(self, parent, soya.Model.get("caterpillar_head"))
 # Ajouter un attribut rapide pour notre nouvel objet.
 # La rapidité est un vecteur de l'objet. Un vecteur est un objet mathématique, utilisé pour
 # le calcul ; contrairement à d'autres objets (Lampe, Caméra, Body, World...) qui ne sont pas 
 # modifiés durant le rendu.
 # Un vecteur est défini par un système de 3 coordonnées (X, Y, Z) ; ici la
 # vitesse est défini dans 'self', exemple : le Head, et avec les coordonnées 0.0, 0.0, -0.2.
 # Souvenez vous que dans Soya, la direction -Z est le devant. 
 # Ceci signifie que le vecteur de vitesse est parallèle à la direction de Head 
 # qui a une longueur de 0.2.
 self.speed = soya.Vector(self, 0.0, 0.0, -0.2)
 # La vitesse de rotation actuelle (sur l'axe Y)
 self.rotation_speed = 0.0
 # Tel que advance_time, begin_round est appellé par la boucle principale.
 # Mais contrairement à advance_time, begin_round est appellé régulièrement, au début de chaque round
 # ; celui ci recoit un argument non "proportionnel".
 # Les décisions doivent être prises dans le begin_round.
 def begin_round(self):
 # Appel de la super implémentation.
 soya.Body.begin_round(self)
 # Calcul de la nouvelle vitesse de rotation : un angle aléatoire entre -25.0 et 25.0 degrés.
 self.rotation_speed = random.uniform(-25.0, 25.0)
 # La vitesse des vecteurs n'a pas besoin d'être recalculée, tel qu'il est exprimé dans le 
 # système de coordonnées de Head
 # CoordSyst.
 # Dans advance_time, nous allons faire un head amélioré.
 def advance_time(self, proportion):
 soya.Body.advance_time(self, proportion)
 # Execution de la rotation, il faut tenir compte de l'argument de proportion.
 self.rotate_y(proportion * self.rotation_speed)
 # Déplaçons le Head grâce au vecteur de vitesse.
 # add_mul_vector est identique à self.add_vector(proportion * self.speed), mais plus rapide.
 # Le vecteur de vitesse et le Head ne sont pas dans le même système de coordonnées, mais
 # Soya fait automatiquement la conversion nécéssaire.
 self.add_mul_vector(proportion, self.speed)
head = Head(scene)
light = soya.Light(scene)
light.set_xyz(2.0, 5.0, 0.0)
camera = soya.Camera(scene)
soya.set_root_widget(camera)
camera.set_xyz(0.0, 15.0, 15.0)
camera.look_at(head)
soya.MainLoop(scene).main_loop()