#!/usr/bin/env python
# coding: utf-8

# # Construction, traitement et affichage de matrices

# ## Définition :
# 
# En mathématiques, une matrice $\textbf{M}(m \times n)$ est un tableau de nombres possédant $m$ lignes et $n$ colonnes. Chaque élément de ce tableau est repéré par deux indices i et j tel que :
# 
# <img src="https://upload.wikimedia.org/wikipedia/commons/thumb/d/d1/Matrice.svg/495px-Matrice.svg.png" width="50%">
# <center><em>Source<a href= "https://fr.wikipedia.org/wiki/Matrice_(math%C3%A9matiques)"> wikipédia</a><em></center>

# ## Création de matrices au format de l'afficheur d'un [BBC micro:bit](https://ericecmorlaix.github.io/adn-Tutoriel_lab_si/IOT/BBC_microbit) :
# 
# On peut représenter les 25 LEDs de l'écran d'un BBC micro:bit par une matrice carrée (5x5) pour laquelle chaque élément peut prendre une valeur entière comprise entre 0 et 9. Cette valeur représente la luminosité de la LED correspondante.
# 
# Par exemple, l'affichage d'un "smiley happy" :
# 
# 
# <img src="https://ericecmorlaix.github.io/img/bbc_happy.png" width="25%">
# <center><em>Image du simulateur <a href= "http://jython.tobiaskohn.ch/">TigerJython</a><em></center>
# 
# correspond à la matrice :
# $$joyeux =\begin{pmatrix}
# & 0 & 0 & 0 & 0 & 0 & \\
# & 0 & 9 & 0 & 9 & 0 & \\
# & 0 & 0 & 0 & 0 & 0 & \\
# & 9 & 0 & 0 & 0 & 9 & \\
# & 0 & 9 & 9 & 9 & 0 & \\
# \end{pmatrix}$$
# 
# et au tableau définit en Python tel que :

# In[ ]:


joyeux = [[0, 0, 0, 0, 0],
          [0, 9, 0, 9, 0],
          [0, 0, 0, 0, 0],
          [9, 0, 0, 0, 9],
          [0, 9, 9, 9, 0]]
joyeux


# <h3 class='fa fa-code' style="color: MediumSeaGreen"> A coder vous même :</h3>
# 
# Définir le tableau pour l'affichage d'un "smiley sad" :

# In[ ]:


triste =


# ## Afficher une matrice :
# 
# ### Affichage en $\LaTeX{}$ dans ce notebook jupyter :
# 
# La fonction `print()` génère un affichage en ligne d'un tableau et non pas un format matricielle, lignes/colonnes :

# In[ ]:


print(joyeux)


# Pour afficher comme il se doit nos matrices dans ce document, nous allons définir une fonction basée sur la fonction `Latex()` du module `IPython.display`
# 
# <h3 class='fa fa-cogs' style="color: darkorange"> A faire vous même :</h3>
# 
# Essayer la fonction suivante avec les matrices `joyeux` puis `triste`.

# In[ ]:


from IPython.display import Latex

def affiche_latex(matrice) :
    '''
    ################################################
    #                                              #
    #   Documentation de la fonction ...........   #
    #                                              #
    ################################################
    
    '''
    
    S = '$$\\begin{pmatrix}'
    for i in range(len(matrice)) :
        S += '&'
        for j in range(len(matrice[i])) :
            S += f' {matrice[i][j]} &'
        S +=" \\\\"
    S +='\\end{pmatrix}$$'
    return Latex(S)


# In[ ]:


affiche_latex(joyeux)


# In[ ]:


affiche_latex(triste)


# Que fait la fonction `affiche_latex()`? Rédiger une docstring pour cette fonction...

# In[ ]:


help(affiche_latex)


# ### Affichage sur l'écran d'un BBC micro:bit :
# 
# >La fonction: `display.set_pixel(x,y,n)` permet d’allumer la LED de la colonne `x` (nombre entier entre 0 et 4) et de la ligne `y` (nombre entier entre 0 et 4) avec un niveau d'intensité lumineuse `n` (nombre entier entre 0 et 9).
# >
# >Exemple: `display.set_pixel(1,2,7)` allume la LED située à la colonne 1 de la ligne 2 au niveau d'intensité lumineuse 7.
# >
# >[Référence](https://python.microbit.org/v/3/reference/display) et [documentation](https://microbit-micropython.readthedocs.io/en/v2-docs/display.html) pour l'affichage sur la [matrice à LED](https://microbit.org/fr/get-started/features/leds-and-buttons/#leds)

# <h3 class='fa fa-code' style="color: darkorange"> A coder vous même :</h3>
# 
# Dans le programme suivant, définir une fonction `affiche_microbit(matrice)` qui :
#    - prend en paramètre une matrice (5x5) dont les éléments sont des nombres entiers compris entre 0 et 9 ;
#    - parcourt cette matrice par ligne et par colonne avec deux boucles `for` imbriquées ;
#    - lit la valeur de chaque élément et l'affecte au pixel (LED) correspondant sur l'écran du BBC micro:bit. 
# 
# Tester votre programme sur [simulateur et sur BBC micro:bit](https://python.microbit.org/v/3) pour les matrices `joyeux` et `triste`.

# In[ ]:


from microbit import *

joyeux = [[0, 0, 0, 0, 0],
          [0, 9, 0, 9, 0],
          [0, 0, 0, 0, 0],
          [9, 0, 0, 0, 9],
          [0, 9, 9, 9, 0]]

def affiche_microbit(matrice) :
    '''
    ################################################
    #                                              #
    #   Documentation de la fonction ...........   #
    #                                              #
    ################################################
    
    '''
    for i 
        for j
            

affiche_microbit(joyeux)


# <h3 class='fa fa-rocket' style="color: tomato"> Prolongement :</h3>
# 
# 1. Modifier le programme pour afficher alternativement les images `joyeux` puis `triste` ;
# 
# 2. Redéfinir une fonction `affiche_microbit(matrice)` utilisant la classe `Image` et la fonction `display.show()` :

# In[ ]:


monImage = Image('33333:36663:36963:36663:33333:')
display.show(monImage)


# ### Affichage sur une grille IPythonBlocks dans ce notebook jupyter :
# 
# Instructions de base pour l'utilisation du module [IPythonBlocks](http://www.ipythonblocks.org/) :

# In[ ]:


# On importe la fonction BlockGrid() du module ipythonblocks
from ipythonblocks import BlockGrid
# On crée un objet maGrille, une instance de BlockGrid
maGrille = BlockGrid(8,5, fill=(0, 0, 0), block_size=30)
# On accède à chaque case de la grille par ces index [i,j] pour modifier sa couleur (rouge, vert, bleu)
maGrille[2,3]=(255, 0, 0)
# On affiche notre grille
maGrille


# <h3 class='fa fa-code' style="color: darkorange"> A coder vous même :</h3>
# 
# Dans le programme suivant, définir une fonction `affiche_ipythonblocks(matrice)` qui :
#    - prend en paramètre une matrice (5x5) dont les éléments sont des nombres entiers compris entre 0 et 9 ;
#    - parcourt cette matrice par ligne et par colonne avec deux boucles `for` imbriquées ;
#    - lit la valeur de chaque élément et l'adapte à la couleur de la case correspondante dans une grille ipythonblocks (5x5). 
# 
# Tester votre programme dans ce notebook pour les matrices `joyeux` et `triste`.

# In[ ]:


from ipythonblocks import BlockGrid

def affiche_ipythonblocks(matrice) :
    '''
    ################################################
    #                                              #
    #   Documentation de la fonction ...........   #
    #                                              #
    ################################################
    
    '''
    maGrille = BlockGrid(5,5, fill=(0, 0, 0), block_size=30)
    for i 
        for j 
            
    return


# In[ ]:


affiche_ipythonblocks(joyeux)


# In[ ]:


affiche_ipythonblocks(triste)


# ## Création de matrices par compréhension :
# 
# Déclarer une matrice élément par élément peux être fastidieux.
# 
# La compréhension de liste va nous permettre d'automatiser cette tâche.
# 
# <h3 class='fa fa-code' style="color: darkorange"> A programmer vous même :</h3>
# 
# En vous inspirant de l'exemple suivant :

# In[ ]:


moins = [[0 if i != 2 else 9 for j in range(5)] for i in range(5)]
moins


# In[ ]:


affiche_latex(moins)


# In[ ]:


affiche_ipythonblocks(moins)


# Proposer des solutions pour générer par compréhension les matrices telles que :
# 
# $$plein\_feux = \begin{pmatrix}
# & 9 & 9 & 9 & 9 & 9 & \\
# & 9 & 9 & 9 & 9 & 9 & \\
# & 9 & 9 & 9 & 9 & 9 & \\
# & 9 & 9 & 9 & 9 & 9 & \\
# & 9 & 9 & 9 & 9 & 9 & \\
# \end{pmatrix}$$

# In[ ]:


plein_feux = []


# In[ ]:


affiche_latex(plein_feux)


# In[ ]:


affiche_ipythonblocks(plein_feux)


# ****
# $$plus = \begin{pmatrix}
# & 0 & 0 & 9 & 0 & 0 & \\
# & 0 & 0 & 9 & 0 & 0 & \\
# & 9 & 9 & 9 & 9 & 9 & \\
# & 0 & 0 & 9 & 0 & 0 & \\
# & 0 & 0 & 9 & 0 & 0 & \\
# \end{pmatrix}$$

# In[ ]:


plus = []


# In[ ]:


affiche_latex(plus)


# In[ ]:


affiche_ipythonblocks(plus)


# $$fois = \begin{pmatrix}
# & 9 & 0 & 0 & 0 & 9 & \\
# & 0 & 9 & 0 & 9 & 0 & \\
# & 0 & 0 & 9 & 0 & 0 & \\
# & 0 & 9 & 0 & 9 & 0 & \\
# & 9 & 0 & 0 & 0 & 9 & \\
# \end{pmatrix}$$

# In[ ]:


fois = []


# In[ ]:


affiche_latex(fois)


# In[ ]:


affiche_ipythonblocks(fois)


# $$ degrade\_Est = \begin{pmatrix}
# & 1 & 3 & 5 & 7 & 9 & \\
# & 1 & 3 & 5 & 7 & 9 & \\
# & 1 & 3 & 5 & 7 & 9 & \\
# & 1 & 3 & 5 & 7 & 9 & \\
# & 1 & 3 & 5 & 7 & 9 & \\
# \end{pmatrix}$$

# In[ ]:


degrade_Est = []


# In[ ]:


affiche_latex(degrade_Est)


# In[ ]:


affiche_ipythonblocks(degrade_Est)


# $$ degrade\_Sud\_Est = \begin{pmatrix}
# & 1 & 2 & 3 & 4 & 5 & \\
# & 2 & 3 & 4 & 5 & 6 & \\
# & 3 & 4 & 5 & 6 & 7 & \\
# & 4 & 5 & 6 & 7 & 8 & \\
# & 5 & 6 & 7 & 8 & 9 & \\
# \end{pmatrix}$$

# In[ ]:


degrade_Sud_Est = []


# In[ ]:


affiche_latex(degrade_Sud_Est)


# In[ ]:


affiche_ipythonblocks(degrade_Sud_Est)


# <h3 class='fa fa-rocket' style="color: tomato"> Prolongement :</h3>
# 
# Imaginer d'autres matrices (5x5) et les afficher dans ce notebook...

# In[ ]:


autre = []


# ## Quelques opérations sur les matrices
# 
# ### Addition ou Soustraction de matrices :
# L'addition (ou la soustraction) de deux matrices de même dimension `mat_A` et `mat_B` est égale à la matrice dont chaque coefficient est obtenu en additionnant (ou en soustrayant) les coefficients de la matrice `mat_A` au coefficient correspondant de la matrice `mat_B`.
# 
# Exemple :
# 
# $$ \begin{pmatrix}
# 1 & 2 & 0 \\
# 4 & 3 & -1 \\
# \end{pmatrix} + \begin{pmatrix}
# 5 & 2 & 3 \\
# 1 & 3 & 4 \\
# \end{pmatrix} =\begin{pmatrix}
# 6 & 4 & 3 \\
# 5 & 6 & 3 \\
# \end{pmatrix}$$
# 
# <h3 class='fa fa-cogs' style="color: darkorange"> A faire vous même :</h3>
# 
# Vérifier cet exemple et documenter la fonction `addition(mat_A, mat_B)` du script suivant :

# In[ ]:


def addition(mat_A, mat_B) :
    '''
    ################################################
    #                                              #
    #   Documentation de la fonction ...........   #
    #                                              #
    ################################################
    
    '''    
    return [[(mat_A[i][j] + mat_B[i][j]) for j in range(len(mat_A[0]))] for i in range(len(mat_A))]

affiche_latex(addition([[1, 2, 0],[4, 3, -1]],[[5, 2, 3],[1, 3, 4]]))


# <h3 class='fa fa-code' style="color: darkorange"> A programmer vous même :</h3>
# 
# - Définir une fonction de soustraction de matrice ;
# - Afficher les matrices résultantes des opérations :
#     - `plein_feux - joyeux`
#     - `plein_feux - fois`
#     - `plein_feux - degrade_Est`
#     - `plein_feux - degrade_Sud_Est`
#     
# - Comparer les images résultantes avec les images retranchées...

# In[ ]:


def soustraction(mat_A, mat_B) :
    '''
    ################################################
    #                                              #
    #   Documentation de la fonction ...........   #
    #                                              #
    ################################################
    
    '''
    return []


# In[ ]:


affiche_latex(soustraction(plein_feux, joyeux))


# In[ ]:


affiche_ipythonblocks(soustraction(plein_feux, joyeux))


# ### Transposition d'une matrice :
# 
# La transposée $^tM$ d'une matrice $M(m\times n)$ est la matrice $(n\times m)$ obtenue en échangeant les lignes et les colonnes de la matrice $M$.
# 
# Exemple :
# 
# Pour : 
# $M=\begin{pmatrix}
# 1 & 2 & 0 \\
# 4 & 3 & -1 \\
# \end{pmatrix}$
# 
# Alors : 
# $^tM=\begin{pmatrix}
# 1 & 4  \\
# 2 & 3  \\
# 0 &-1 
# \end{pmatrix}$
# 
# <h3 class='fa fa-code' style="color: darkorange"> A coder vous même :</h3>
# 
# Définir une fonction `transpose(matrice)` qui :
#    - prend en paramètre une matrice (mxn) dont les éléments sont des nombres entiers ;
#    - renvoie la matrice transposée (nxm). 
# 
# Appliquer votre fonction pour calculer les tranposées des matrices (5x5) précédentes...

# In[ ]:


def transpose(matrice) :
    '''
    ################################################
    #                                              #
    #   Documentation de la fonction ...........   #
    #                                              #
    ################################################
    
    '''
    return []


# ## Un peu d'animation :
# 
# ### Sur un BBC micro:bit :
# 
# <h3 class='fa fa-cogs' style="color: darkorange"> A faire vous même :</h3>
# 
# - Compléter le programme suivant en y intégrant vos développements précédents puis le tester sur simulateur et sur BBC micro:bit ;
# - Expliquer le calcul `k % len(ecrans)`

# In[ ]:


from microbit import *

plein_feux = []
plus = []
fois = []


def affiche_microbit(matrice) :
    for i 
        for j
    return
            
def soustraction(mat_A, mat_B) :
    return []


ecrans = [plein_feux,
          soustraction(plein_feux, plus),
          plus,
          soustraction(plein_feux, plein_feux),
          fois,
          soustraction(plein_feux, fois)]            
            
k = 0
 
while k < 100 :
    affiche_microbit(ecrans[k % len(ecrans)])
    sleep(500)
    k+=1


# ### Avec IpythonBlocks dans ce notebook :
# 
# La fonction `flash()` d'une instance de BlockGrid permet un affichage animé selon le paramètre de temps `display_time` :

# In[ ]:


from ipythonblocks import BlockGrid

ecrans = [plein_feux,
          soustraction(plein_feux, plus),
          plus,
          soustraction(plein_feux, plein_feux),
          fois,
          soustraction(plein_feux, fois)]            
            
k = 0
 
while k < 100 :
    affiche_ipythonblocks(ecrans[k % len(ecrans)]).flash(display_time=0.5)
    k+=1


# ## Affichage avec ipycanvas dans ce notebook jupyter :
# 
# Reproduire aves le module ipycanvas un affichage similaire à celui obtenu avec IPythonBlocks :

# In[ ]:


from ipycanvas import Canvas

def affiche_ipycanvas(matrice) :
    maGrille = Canvas(width=..., height=...)
    for i  
        for j 
            
            
            
    return maGrille


# In[ ]:


affiche_ipycanvas(joyeux)


# <h3 class='fa fa-rocket' style="color: tomato"> Prolongement :</h3>
# 
# Imaginer d'autres animations...
# 
# Développer de nouvelles matrices...
# 
# Développer de nouvelles opérations sur des matrices...
# 
# Développer d'autres fonctions d'affichage :
#     - Dans un notebook avec des fonctions Ipython.display comme HTML, SVG, 
#     - Pour d'autres matrices à LEDs :
#         - Matrice 8x8 pour BBC microbit
#         - SenseHat sur RaspberryPi
#         - Anneau pour BBC microbit
#         - Anneau de CPX
#         - Anneau d'Halocode     
# 

# ****
# ## Références aux programmes :
# 
# <style type="text/css">
# .tg  {border-collapse:collapse;border-spacing:0;}
# .tg td{font-family:Arial, sans-serif;font-size:14px;padding:10px 5px;border-style:solid;border-width:1px;overflow:hidden;word-break:normal;border-color:black;}
# .tg th{font-family:Arial, sans-serif;font-size:14px;font-weight:normal;padding:10px 5px;border-style:solid;border-width:1px;overflow:hidden;word-break:normal;border-color:black;}
# .tg .tg-cv16{font-weight:bold;background-color:#dae8fc;border-color:inherit;text-align:center}
# .tg .tg-xldj{border-color:inherit;text-align:left}
# </style>
# <table class="tg">
#   <tr>
#     <th class="tg-cv16">Contenus</th>
#     <th class="tg-cv16">Capacités attendues</th>
#     <th class="tg-cv16">Commentaires</th>
#   </tr>
#   
#   <tr>
#     <td class="tg-xldj">Tableau indexé,<br> tableau donné en compréhension</td>
#     <td class="tg-xldj">Lire et modifier les éléments d’un tableau grâce à leurs index.<br> Construire un tableau par compréhension.<br> Utiliser des tableaux de tableaux pour représenter des matrices : notation a [i] [j].<br>Itérer sur les éléments d’un tableau.
# </td>
#     <td class="tg-xldj">Seuls les tableaux dont les éléments sont du même type sont présentés.<br> Aucune connaissance des
# tranches (slices) n’est exigible. <br> L’aspect dynamique des tableaux de Python n’est pas évoqué.<br> Python identifie listes et tableaux. <br>Il n’est pas fait référence aux tableaux de la bibliothèque NumPy.
# </td>
#   </tr>
#  
# </table>
# <br>
# <br>
# <table class="tg">
#   <tr>
#     <th class="tg-cv16">Contenus</th>
#     <th class="tg-cv16">Capacités attendues</th>
#     <th class="tg-cv16">Commentaires</th>
#   </tr>
#   <tr>
#     <td class="tg-xldj">Spécification.</td>
#     <td class="tg-xldj">Prototyper une fonction.<br>Décrire les préconditions sur les arguments.<br>Décrire des postconditions sur les résultats.</td>
#     <td class="tg-xldj">Des assertions peuvent être utilisées pour garantir des préconditions ou des postconditions.</td>
#   </tr>
#   <tr>
#     <td class="tg-xldj">Mise au point de programmes</td>
#     <td class="tg-xldj">Utiliser des jeux de tests.</td>
#     <td class="tg-xldj">L’importance de la qualité et du nombre des tests est mise en évidence.<br>Le succès d’un jeu de tests ne garantit pas la correction d’un programme.</td>
#   </tr>
#   <tr>
#     <td class="tg-xldj">Utilisation de bibliothèques</td>
#     <td class="tg-xldj">Utiliser la documentation d’une bibliothèque.</td>
#     <td class="tg-xldj">Aucune connaissance exhaustive d’une bibliothèque particulière n’est exigible.</td>
#   </tr>  
# </table>

# <a rel="license" href="http://creativecommons.org/licenses/by-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-sa/4.0/88x31.png" /></a><br />Ce document est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-sa/4.0/">Licence Creative Commons Attribution -  Partage dans les Mêmes Conditions 4.0 International</a>.
# 
# Pour toute question, suggestion ou commentaire : <a href="mailto:eric.madec@ecmorlaix.fr">eric.madec@ecmorlaix.fr</a>