lilliput-ae-reference-implementation

commit a3663b7b3bdc092fb0667ea6c16b8e9a6cf4cf73
parent aaf0d2c49f343e909dc69b487056ca31238ffabf
Author: Kévin Le Gouguec <kevin.legouguec@airbus.com>
Date:   Thu, 21 Mar 2019 16:37:26 +0100

[implem-python] Utilisation des divisions entières //

Plutôt que int() ; moins de bruit.

… Au passage, simplification (j'espère) de ArrayToBlockbytesMatrix() :

- pas besoin  d'initialiser la matrice  à zéro ; suffit  d'ajouter les
  octets et les blocs comme ils viennent,

- AFAICT,

    int((length + (BLOCK_BYTES - (length % BLOCK_BYTES))) / BLOCK_BYTES)

  quand length  % BLOCK_BYTES  > 0, c'est  juste une  façon compliquée
  d'écrire

    int(length/BLOCK_BYTES) + 1

Diffstat:
M
python/helpers.py
 | 
27
+++++++++++++++------------
M
python/lilliput_ae_1.py
 | 
11
++++++-----

2 files changed, 21 insertions(+), 17 deletions(-)
diff --git a/python/helpers.py b/python/helpers.py
@@ -3,20 +3,23 @@ from lilliput_tbc import LilliputTBCEnc
 
 
 def ArrayToBlockbytesMatrix(array):
-    length = len(array)
-    pad = 0
-    if length % BLOCK_BYTES == 0:
-        number_blocks = int(length / BLOCK_BYTES)
-    else:
-        number_blocks = int((length + (BLOCK_BYTES - (length % BLOCK_BYTES))) / BLOCK_BYTES)
-        pad = 1
+    vector = list(array)
+
+    blocks_nb = len(vector)//BLOCK_BYTES
+
+    block_starts = (
+        i*BLOCK_BYTES for i in range(blocks_nb)
+    )
+
+    matrix = [
+        vector[start:start+BLOCK_BYTES] for start in block_starts
+    ]
 
-    matrix = [[0] * BLOCK_BYTES for block in range(0, number_blocks - pad)]
-    if pad == 1:
-        matrix.append([0] * (length % BLOCK_BYTES))
+    padding_len = len(vector)%BLOCK_BYTES
 
-    for byte in range(0, length):
-        matrix[int(byte / BLOCK_BYTES)][byte % BLOCK_BYTES] = array[byte]
+    if padding_len > 0:
+        padding = vector[-padding_len:]
+        matrix.append(padding)
 
     return matrix
 
diff --git a/python/lilliput_ae_1.py b/python/lilliput_ae_1.py
@@ -31,13 +31,14 @@ def LowPart(array, number_bits):
 
     lower_part = shifted & mask
 
-    will_padd = 0
+    will_pad = 0
     if number_bits % 8 != 0:
-        will_padd = 1
+        will_pad = 1
 
-    lower_part_byte = [0 for byte in range(0, int(number_bits / 8) + will_padd)]
-    for byte in range(0, int(number_bits / 8) + will_padd):
-        lower_part_byte[byte] = lower_part & 0xff
+    lower_part_byte = []
+    nb_bytes = number_bits//8 + will_pad
+    for byte in range(nb_bytes):
+        lower_part_byte.append(lower_part & 0xff)
         lower_part = lower_part >> 8
 
     return lower_part_byte