Added Chapter_5

Chapter_5/ex3.py

+from Vecteur import Vecteur
+from Histogram import Histogram
+from random import random
+from math import acos, pi
+
+
+h = Histogram(100,0,pi/2)
+for i in range(int(1e6)):
+    v1 = Vecteur(random(),random(),random())
+    v2 = Vecteur(random(),random(),random())
+    angle = acos(v1.prod_scal(v2)/(v1.norme()*v2.norme()))
+    h.fill(angle)
+
+h.draw()
+
+

Chapter_5/ex4_pendu.py

+from word_list import word_list
+
+class pendu:
+    def __init__(self,n_letters):
+        self.previous_template='_'*n_letters
+        self.word_list = []
+        self.letter_candidates = "abcdefghijklmnopqrstuvwxyz"
+        print("Setting-up solver...")
+        for (index,word) in enumerate(word_list):
+            if len(word)==n_letters:
+                self.word_list.append(word)
+        print("Done !")
+
+
+    def count_letters(self):
+        counter = {}
+        for word in self.word_list:
+            for letter in self.letter_candidates:
+                if letter in word:
+                    if letter in counter.keys():
+                        counter[letter] += 1
+                    else:
+                        counter[letter] =  1
+
+        counter = sorted([ [x[1], x[0]] for x in counter.items()],reverse=True)
+
+        print("{} words remaining.".format(len(self.word_list)))
+        if len(self.word_list) < 50:
+            for w in self.word_list:
+                print(w)
+
+        print("List of letters to try (sorted by probability) :")
+        to_print = ""
+        for k in counter:
+            to_print+="{}({})  ".format(k[1],k[0])
+        print(to_print)
+
+
+    def try_letter(self):
+        letter_tested = ''
+        while len(letter_tested)!=1:
+            letter_tested = input("Letter tried :")
+        self.letter_candidates = self.letter_candidates.replace(letter_tested,"")
+        print("Remaining letters : {}".format(self.letter_candidates))
+
+
+    def get_template(self):
+        print("Last template : {}".format(self.previous_template))
+        template = ''
+        while len(template) != len(self.previous_template):
+            template = input("New template : ")
+        self.previous_template = template
+
+    def exclude_mismatch(self):
+        for word_index , word in reversed(list(enumerate(self.word_list))):
+            for index,letter in enumerate(self.previous_template):
+                if letter != "_" and word[index] != letter:
+                    self.word_list.pop(word_index)
+                    break
+                if letter == "_" and not word[index] in self.letter_candidates:
+                    self.word_list.pop(word_index)
+                    break
+
+    def turn(self):
+
+        self.count_letters()
+        self.try_letter()
+        self.get_template()
+        self.exclude_mismatch()
+
+        if len(self.word_list) == 1:
+            print("Only remaining word : {}".format(self.word_list[0]))
+            return False
+        if len(self.word_list) == 0:
+            print("Error, no more words in list... GAME OVER...")
+            return False
+
+        return True
+
+
+if __name__ == '__main__':
+    x = int(input("Combien de lettres ? "))
+    p = pendu(x)
+    while p.turn():
+        pass

Chapter_5/histogram.py

+
+
+class histogram:
+    def __init__(self, n_bins, a, b):
+        """Crée un histograme de n_bins réparties uniformément entre a et b"""
+        self._data = [0 for i in range(n_bins)]
+        self._n_bins = n_bins
+        self._a = a
+        self._b = b
+
+    def fill(self, x):
+        """Remplis la bin correspondant à la valeur 'x'"""
+        bin_number = int((x-self._a)*self._n_bins/(self._b-self._a))
+        if bin_number >= 0 and bin_number < self._n_bins:
+            self._data[bin_number] += 1
+            return bin_number
+        else:
+            print("Warning, {} out of bounds.".format(x))
+            return -1
+
+    def get_maximum(self):
+        """Retourne le maximum de l'histogramme"""
+        maximum = self._data[0]
+        for x in self._data[1:]:
+            if x > maximum:
+                maximum = x
+        return maximum
+
+
+    def draw(self):
+        """Affiche l'histogramme en console"""
+        y_max = self.get_maximum()
+        scale = 1.
+        if y_max > 50:
+            scale = 50*1./y_max
+            y_max = 50
+        # vertical axis : 50 pxl
+        y = y_max + 1
+        while y > 0:
+            to_print = ""
+            if (y == y_max+1):
+                to_print = "y ^"
+            else:
+                to_print = "  |"
+
+            for x in range(self._n_bins):
+                if self._data[x] >= y/scale:
+                    to_print += "#"
+                else:
+                    to_print += " "
+            print (to_print)
+            y-=1
+
+        print (" -"+"+"+(self._n_bins-1)*"-"+">")
+        print ("  |"+(self._n_bins-1)*" "+"x")
+        if scale != 1:
+            print ("y-axis scale : 1 # = {}".format(1./scale))
+
+
+
+
+if __name__=="__main__":
+    h = histogram(10,0,1)
+    h.fill(0.5)
+    h.fill(0.5)
+    h.fill(0.5)
+    h.fill(0.1)
+    h.fill(2)
+    h.fill(-1)
+    h.draw()
+
+    h2 = histogram(100,-5,5)
+    from random import gauss
+    for i in range(int(100000)):
+        h2.fill(gauss(0,1))
+    h2.draw()

Chapter_5/vecteur.py

+import math
+
+class vecteur:
+    """Classe vecteur de nombres de dimension arbitraire."""
+
+    def __init__(self, *coord):
+        """Initialise un vecteur de coordonnees "coord" """
+        self._coord = [c for c in coord]
+
+    def get_vec(self):
+        """Retourne un tuple contenant les coordonnees du vecteur"""
+        return tuple(self._coord)
+
+    def set(self,*coord):
+        """Donne les coordonnees "coord" au vecteur"""
+        self._coord = [c for c in coord]
+
+    def set_component(self, index, value):
+        """Donne la valeur 'value' a la composante 'index' du vecteur"""
+        self._coord[index] = value
+
+    def norme(self):
+        """Retourne la norme du vecteur"""
+        nn = 0
+        for x in self._coord:
+            nn += x*x
+        return math.sqrt(nn)
+
+    def prod_scal(self, vec):
+        """Retourne le produit scalaire du vecteur avec vec"""
+        if not len(vec._coord) == len(self._coord):
+            print("Error, vectors of different dimensions...")
+            return 0
+        ps = 0
+        for i in range(len(self._coord)):
+            ps+=self._coord[i] * vec._coord[i]
+        return ps
+
+    def prod_vec(self,vec):
+        """Retourne le produit vectoriel du vecteur avec vec"""
+        if not len(vec._coord) == 3 or not len(self._coord)==3:
+            print("Error, only possible for dim 3 vectors.")
+            return Vecteur(0,0,0)
+        return Vecteur(
+                self._coord[1]*vec._coord[2] - self._coord[2]*vec._coord[1],
+               -self._coord[0]*vec._coord[2] + self._coord[2]*vec._coord[0],
+                self._coord[0]*vec._coord[1] - self._coord[1]*vec._coord[0])
+
+if __name__ == '__main__':
+    print("Debugging...")
+    u = vecteur()
+    u.set(1,2,3)
+    print("vecteur u = {} et |u| = {}".format(u.get_vec(),u.norme()))
+
+    v = vecteur(4,5,6)
+    v.set_component(1,0)
+    print("vecteur v = {} et |v| = {}".format(v.get_vec(),v.norme()))
+
+    print("u.v = {}".format(u.prod_scal(v)))
+    print("v.u = {}".format(v.prod_scal(u)))
+    w = u.prod_vec(v)
+    print("w = u x v = {}".format(w.get_vec()))
+    print("    v x u = {}".format(v.prod_vec(u).get_vec()))
+    print("w.u = {} ; u.w = {}".format(w.prod_scal(u),u.prod_scal(w)))
+    print("w.v = {} ; v.w = {}".format(w.prod_scal(v),v.prod_scal(w)))
+
+