Abend S0C4 COBOL

Ceci est une explication supplémentaire sur l’exception Abend S0C4 dans COBOL En informatique, « fin anormale » ou « fin anormale » signifie que le logiciel fonctionne de manière anormale et inopinée, ou que le programme plante. Cobol est un langage de programmation créé en 1959. Son nom est l’acronyme de COmmon Business Oriented Language, et il révèle sa vocation première: devenir un langage universel de programmation d’applications métier. Aujourd’hui, il est principalement utilisé pour la banque, l’assurance, …

Abend S0C4 COBOL apprendre cobol

Introduction

Abend S0C4 Interrompre le type de programme « protégé par exception » Erreur de conversion d’adresse virtuelle (conversion de segment ou exception de conversion de page), erreur de page et sans interruption Ou essayez plus fréquemment de violer la protection de la mémoire: accès à une zone de mémoire protégée ou mauvaise adresse

Solution

Capacité de la table supérieure

La longueur de la zone de communication avec les sous-programmes est incorrecte

Ou le nombre de régions incorrectes Fichier variable mal défini

Erreur -BLOCKSIZE


Les autres informations – abend S0C4 COBOL

« Impossible de convertir l’adresse virtuelle en adresse réelle. »

Erreur de protection de fichier ou de programme. La clé de protection est incompatible avec le contenu de la zone protégée du PSW, et l’instruction a pour fonction de modifier la mémoire (couverture mémoire).

La raison:

– Dépassement d’index
– Essaie de faire 2 fois close sur le même fichier
– DCB non valide
– Opérations sur les dossiers fermés

Vérifier la version de pandas installée


http://128mots.com/index.php/category/python/

ValueError: Unable to parse string – Python Pandas error

En général vous obtenez cette erreur « ValueError: Unable to parse string » lorsque vous cherchez à convertir en numérique avec la fonction

pd.to_numeric(s)

Introduction – ValueError: Unable to parse string

L’erreur est en général du à la présence de valeur nulle NaN dans le dataset.

Plutôt que d’être en erreur, nous pouvons forcer pandas à considérer NaN comme une valeur numérique manquante / incorrecte.

Nous pouvons contraindre les valeurs invalides à NaN comme suit :

pd.to_numeric(s, errors='coerce')

Obtenir la version installée de pandas

Aussi vous pouvez consulter sur ce site : https://pandas.pydata.org/pandas-docs/stable/getting_started/install.html

Vous pouvez vérifier facilement la version installée sur votre machine en exécutant le code python suivant :

import pandas as pd 
print(pd.__version__)

Vous obtenez par exemple :

ValueError: Unable to parse string
pandas csv - Comment charger/sauvegarder avec pandas en Python ?
Vérifier la version de pandas installée

http://128mots.com/index.php/category/python/

Pandas Merge, Join et concatenation

Python est un langage adapté pour l’analyse de donnée, le package Pandas est central dans la gestion et l’analyse de donnée ainsi que leur importation. Dans cet article voyons le join, merge, concatenate.

Introduction – Pandas Merge Join et concat

La librairie pandas est caractérisée par l’objet DataFrame qui permet de manipuler des données facilement et efficacement.

Pour installer pandas si ce n’est pas encore le cas sur votre poste :

pip install pandas

Aussi vous pouvez consulter sur ce site : https://pandas.pydata.org/pandas-docs/stable/getting_started/install.html

Vous pouvez vérifier facilement la version installée sur votre machine en exécutant le code python suivant :

import pandas as pd 
print(pd.__version__)

Vous obtenez par exemple :

pandas csv - Comment charger/sauvegarder avec pandas en Python ?
Vérifier la version de pandas installée

Concatener des DataFrame en utilisant la fonction .concat() :

Voici un exemple :

import pandas as pd 
data1 = {'Ville':['Paris','Marseille','Lyon'],'CodePostal':['75000','13000','69000']}
data2 = {'Ville':['Metz','Brest','Perpignan'],'CodePostal':['57000','29200','66000']}
df1 = pd.DataFrame(data1)
df2 = pd.DataFrame(data2)
res1 = pd.concat([df1,df2])

print('****** Datafram 1 ******')
print(df1)
print('****** Datafram 2 ******')
print(df2)
print('****** Concat ******')
print(res1)

Voici la sortie :

****** Datafram 1 ******
       Ville CodePostal
0      Paris      75000
1  Marseille      13000
2       Lyon      69000
****** Datafram 2 ******
       Ville CodePostal
0       Metz      57000
1      Brest      29200
2  Perpignan      66000
****** Concat ******
       Ville CodePostal
0      Paris      75000
1  Marseille      13000
2       Lyon      69000
0       Metz      57000
1      Brest      29200
2  Perpignan      66000
Pandas Merge, Join et concatenation

Concaténer sur un axe différent :

Exemple de concaténation avec pandas sur un axe différent :

import pandas as pd 
data1 = {'Ville':['Paris','Marseille','Lyon'],'CodePostal':['75000','13000','69000']}
data2 = {'Ville':['Metz','Brest','Perpignan'],'CodePostal':['57000','29200','66000']}
df1 = pd.DataFrame(data1)
df2 = pd.DataFrame(data2)
res1 = pd.concat([df1, df2], axis=1, join='inner')

print('****** Datafram 1 ******')
print(df1)
print('****** Datafram 2 ******')
print(df2)
print('****** Concat on different axes ******')
print(res1)

La sortie est la suivante :

****** Datafram 1 ******
       Ville CodePostal
0      Paris      75000
1  Marseille      13000
2       Lyon      69000
****** Datafram 2 ******
       Ville CodePostal
0       Metz      57000
1      Brest      29200
2  Perpignan      66000
****** Intersection ******
       Ville CodePostal      Ville CodePostal
0      Paris      75000       Metz      57000
1  Marseille      13000      Brest      29200
2       Lyon      69000  Perpignan      66000

Autre exemple avec .append():

import pandas as pd 
data1 = {'Ville':['Paris','Marseille','Lyon'],'CodePostal':['75000','13000','69000']}
data2 = {'Ville':['Metz','Brest','Perpignan'],'CodePostal':['57000','29200','66000']}
df1 = pd.DataFrame(data1)
df2 = pd.DataFrame(data2)
res1 = df1.append(df2)

print('****** Datafram 1 ******')
print(df1)
print('****** Datafram 2 ******')
print(df2)
print('****** Append ******')
print(res1)

Et la sortie est :

****** Datafram 1 ******
       Ville CodePostal
0      Paris      75000
1  Marseille      13000
2       Lyon      69000
****** Datafram 2 ******
       Ville CodePostal
0       Metz      57000
1      Brest      29200
2  Perpignan      66000
****** Append ******
       Ville CodePostal
0      Paris      75000
1  Marseille      13000
2       Lyon      69000
0       Metz      57000
1      Brest      29200
2  Perpignan      66000

Merge de dataframe avec pandas :

Voici un exemple de merge :

import pandas as pd 
data1 = {'Ville':['Paris','Marseille','Lyon'],'CodePostal':['75000','13000','69000']}
data2 = {'Ville':['Metz','Brest','Perpignan','Paris'],'CodePostal':['57000','29200','66000','75001']}
df1 = pd.DataFrame(data1)
df2 = pd.DataFrame(data2)
res1 = res = pd.merge(df1, df2, on='Ville')

print('****** Datafram 1 ******')
print(df1)
print('****** Datafram 2 ******')
print(df2)
print('****** Merging ******')
print(res1)

Voici la sortie :

****** Datafram 1 ******
       Ville CodePostal
0      Paris      75000
1  Marseille      13000
2       Lyon      69000
****** Datafram 2 ******
       Ville CodePostal
0       Metz      57000
1      Brest      29200
2  Perpignan      66000
3      Paris      75001
****** Merging ******
   Ville CodePostal_x CodePostal_y
0  Paris        75000        75001

Jointure pandas python :

import pandas as pd 
data1 = {'Ville':['Paris','Marseille','Lyon'],'CodePostal':['75000','13000','69000']}
data2 = {'Ville2':['Metz','Brest','Perpignan','Paris'],'Nbhabitant':['10000','20000','30000','40000']}
df1 = pd.DataFrame(data1)
df2 = pd.DataFrame(data2)
res1 = df1.join(df2,how='inner')

print('****** Datafram 1 ******')
print(df1)
print('****** Datafram 2 ******')
print(df2)
print('****** Join ******')
print(res1)
****** Datafram 1 ******
       Ville CodePostal
0      Paris      75000
1  Marseille      13000
2       Lyon      69000
****** Datafram 2 ******
      Ville2 Nbhabitant
0       Metz      10000
1      Brest      20000
2  Perpignan      30000
3      Paris      40000
****** Join ******
       Ville CodePostal     Ville2 Nbhabitant
0      Paris      75000       Metz      10000
1  Marseille      13000      Brest      20000
2       Lyon      69000  Perpignan      30000

http://128mots.com/index.php/category/python/

pandas csv – Comment charger/sauvegarder avec pandas en Python ?

Python est un langage adapté pour l’analyse de donnée, le package Pandas est central dans la gestion et l’analyse de donnée ainsi que leur importation. Dans cet article voyons comment charger un fichier de donnée csv excel par exemple avec pandas.

Introduction

La librairie pandas est caractérisée par l’objet DataFrame qui permet de manipuler des données facilement et efficacement.

Pour installer pandas si ce n’est pas encore le cas sur votre poste :

pip install pandas

Aussi vous pouvez consulter sur ce site : https://pandas.pydata.org/pandas-docs/stable/getting_started/install.html

Vous pouvez vérifier facilement la version installée sur votre machine en exécutant le code python suivant :

import pandas as pd 
print(pd.__version__)

Vous obtenez par exemple :

pandas csv - Comment charger/sauvegarder avec pandas en Python ?
Vérifier la version de pandas installée

Charger un fichier csv dans un dataframe pandas :

Pour charger un fichier csv avec python c’est assez simple : vous utilisez la fonction read_csv avec une url ou un fichier en local.

blockdata = pd.read_csv('./blockdata.txt',index_col=0, parse_dates=True)

Voici quelques paramètres utiles :

ParamètreUtilisation
seppermet de préciser un séparateur différent du séparateur par défaut ‘,’
index_colPermet de préciser la colonne à utiliser comme index
use_colsPermet de préciser les colonnes à utiliser

Sauvegarder/Enregistrer un dataframe pandas dans un fichier csv :

Exemple de sauvegarde :

blockdata.to_csv('outblock4.csv')

http://128mots.com/index.php/category/python/

Implémentation Python de l’algorithme de Bellman-Ford

Introduction – algorithme de Bellman-Ford python

Cet article fait suite à d’autres article sur l’implémentation python d’algorithme : l’article suivant sur l’algorithme de Dijkstra : http://128mots.com/index.php/2021/03/01/implementation-python-de-lalgorithme-de-floyd-warshall/

def bellmanFord(graph, sommetDepart):
    distances = {} 
    predecesseurs = {}
    for sommet in graph:
        distances[sommet] = np.inf
        predecesseurs[sommet] = None
    distances[sommetDepart] = 0
    

    for i in range(len(graph)-1):
        for j in graph:
            for k in graph[j]: 
                if distances[k] > distances[j] + graph[j][k]:
                    distances[k]  = distances[j] + graph[j][k]
                    predecesseurs[k] = j
    for i in graph:
        for j in graph[i]:
            assert distances[j] <= distances[i] + graph[i][j]

    return distances, predecesseurs

#Liste d'ajacence du graphe
graph = {'A':{'B':15,'C':4},'B':{'E':5},'C':{'E':11,'D':2},'D':{'E':3},'E':{}}
distances, predecesseurs = bellmanFord(graph,'A')
print("Plus courte distance pour chaque sommet de départ :")
for v in distances: print(str(v) + '-' + str(distances[v]))

Implémentation Python de l’algorithme de floyd-warshall

Introduction – algorithme de floyd warshall python

Implémentation Python de l’algorithme de floyd-warshall

Cet article fait suite à d’autres article sur l’implémentation python d’algorithme : l’article suivant sur l’algorithme de Dijkstra : http://128mots.com/index.php/2020/02/17/lalgorithme-de-dijkstra-dans-un-graphe-pondere-et-oriente-en-plus-de-128-mots/

import numpy as np

def floydwarshall(graph):
    distances = {}
    predecesseurs = {}
    for u in graph:
        distances[u] = {}
        predecesseurs[u] = {}
        for v in graph:
            distances[u][v] = np.inf
            predecesseurs[u][v] = -1
        distances[u][u] = 0
        for voisin in graph[u]:
            distances[u][voisin] = graph[u][voisin]
            predecesseurs[u][voisin] = u

    for t in graph:
        for u in graph:
            for v in graph:
                nouvellesDistances = distances[u][t] + distances[t][v]
                if nouvellesDistances < distances[u][v]:
                    distances[u][v] = nouvellesDistances
                    predecesseurs[u][v] = predecesseurs[t][v] 
    return distances, predecesseurs

#Liste d'ajacence du graphe
graph = {'A':{'B':15,'C':4},'B':{'E':5},'C':{'E':11,'D':2},'D':{'E':3},'E':{}}
distances, predecesseurs = floydwarshall(graph)
print("Prédecesseur du sommet d'arrivée dans le chemin le plus court (-1 : chemin impossible):")
for v in predecesseurs: print(str(v) + '' + str(predecesseurs[v]))
print("Plus courte distance pour chaque sommet de départ (inf : chemin impossible) :")
for v in distances: print(str(v) + '' + str(distances[v]))

L’algorithme pour miner le bitcoin en Python

Cet article décrit une implémentation en python du minage du bitcoin qui s’appuie sur un algorithme basé sur un double hash SHA-256.

bitcoin python algorithme miner minage

Introduction – Principe de l’agorithme de minage du bitcoin

Les mineurs du réseau bitcoin doivent rechercher le nonce qui est un un nombre de 32 bits. Le mineur va tester successivement plusieurs NONCE (1,2,3 ….10^32-1), pour chacun des nonce il crée l’entête suivante et le hasher 2 fois avec une fonction de hachage SHA-256 bits.

FieldDescriptionSize
versionVersion 4
Hash du bloc précédent256-bit hash du block précédent32
Merkle rootIl s’agit d’un hash sur les données du bloc. Il est fournit au mineur et il contient un résumé des transactions qui sont contenues dans le bloc. 32
timeUn timestamp numérique qui représente le nombre de seconde depuis 1970-01-01T00:00 UTC4
bitsLa cible actuelle (Current target) en format compacté4
nonce32-bit number (starts at 0)4

Une fois le hash obtenu le mineur doit ensuite vérifier que le hash obtenu est inférieur au facteur de difficulté cible du bloc. Si le hash obtenu est supérieur alors le nonce n’est pas le bon il faut en tester un autre.

Exemple sur le bloc 671712

Si vous utilisez un explotateur de blochain bitoin (par exemple blocstream info), si on prends par exemple le bloc 671712 :

https://blockstream.info/block/000000000000000000062a949bc297739a12e639ba9e2107638b469afe11d0f8?expand

bitcoin python algorithme miner minage

Dans ce cas voici un algorithme en python qui permet de miner ce bloc :

Dans cette simulation j’affiche le header et le hash calculé ainsi que le hash rate.

Le nonce a trouver pour le bloc 671712 était 4107802144

Soit en hexa : 0xf4d81620

Cette algorithme démarre avec un nonce = 4107802144 – 400 nous allons faire comme si on était à très proche de trouver le bloc (il manque 400 double hash à effectuer pour trouver le bloc) :

import hashlib
from hashlib import sha256
import time
import struct
import binascii
import datetime
from binascii import unhexlify, hexlify
from dateutil import parser
from datetime import datetime
from datetime import timedelta 

nontrouve = True
dtprec = datetime.now()
inonc = 4107802134 - 400 #Starting 400 before the good nonce
resultat = []

while(nontrouve):
    inonc +=1
    if(inonc%50==0):
        print(str(round(timedelta(seconds=1)/(datetime.now() - dtprec))) + ' H/s')
    dtprec = datetime.now()
    header_hex = (binascii.hexlify(struct.Struct('<L').pack(int('0x2fffe000',16))).decode()  + 
     binascii.hexlify(binascii.unhexlify('000000000000000000078908d256fa7a9f97b2e1ea532fb1ce45ee4bf050d221')[::-1]).decode()+
     binascii.hexlify(binascii.unhexlify('c504fc3a406f11c7c5b598da7f50916f4e298041e6f9b91535a80db113af109a')[::-1]).decode() +
     binascii.hexlify(struct.Struct('<L').pack(int(hex(int(parser.parse('2021-02-22 15:14:22 GMT +1').timestamp())-3600),16))).decode() +
     binascii.hexlify(struct.Struct('<L').pack(int("0x170cf4e3",16))).decode() + 
     binascii.hexlify(struct.Struct('<L').pack(int(hex(inonc),16))).decode()) 
    header_bin = unhexlify(header_hex)
    dt1 = datetime.now().strftime("%H:%M:%S.%f")
    hash = hashlib.sha256(hashlib.sha256(header_bin).digest()).digest()
    hexlify(hash).decode("utf-8")
    hexlify(hash[::-1]).decode("utf-8")
    hash=hexlify(hash[::-1]).decode("utf-8") 
    resultat.append([round(int(hash,16)/10**65)])
    
    MAX_TARGET = int("00000000FFFF0000000000000000000000000000000000000000000000000000", 16)           
    Difficulty = 21724134900047.27                     
    target = int(MAX_TARGET / Difficulty)
    target32 = '{:0>64x}'.format(target)    
    if(int(hash,16) < int(target32,16)):
        print('###########BLOC MINED###################')
        print('HEADER=' + header_hex)
        print('HASH=' + hash)
        print('NONCE=' + str(inonc))
        print('NONCE (hex)=' + hex(inonc))
        print('###########BLOC MINED###################')
        break

La sortie est la suivante :

1149 H/s
4405 H/s
4115 H/s
1534 H/s
3831 H/s
2392 H/s
4386 H/s
3165 H/s
###########BLOC MINED###################
HEADER=00e0ff2f21d250f04bee45ceb12f53eae1b2979f7afa56d20889070000000000000000009a10af13b10da83515b9f9e64180294e6f91507fda98b5c5c7116f403afc04c53ebc3360e3f40c172016d8f4
HASH=000000000000000000062a949bc297739a12e639ba9e2107638b469afe11d0f8
NONCE=4107802144
NONCE (hex)=0xf4d81620
###########BLOC MINED###################

Lien externe – minage de bitcoin en python

https://en.bitcoin.it/wiki/Block_hashing_algorithm

Lien interne

http://128mots.com/index.php/2020/03/30/construire-une-application-decentralisee-full-stack-pas-a-pas-ethereum-blockchain-dapp-en-plus-de-128-mots-partie-1/

Implémentation des graphes en Python – Exemple BFS

Implémentation des graphes en Python par l’exemple : Le parcours en largeur python d’un graphe (BFS) est un algorithme utilisé pour parcourir les structures de donnée de graphe. BFS met en œuvre une stratégie spécifique pour visiter tous les sommets d’un graphe.

Introduction – Implémentation des graphes en Python

BFS commence par un sommet, puis il vérifie les voisins du sommet initial, puis les voisins des voisins, etc.

En entrée de l’algorithme il y a le graphe G et un sommet de départ D pour lequel on considère que la distance est 0.

En sortie de l’algorithme sont calculées toutes les distances entre le sommet D et chaque sommet du graphe G ainsi que l’arbre couvrant si le graphe G est connexe (c’est à dire que pour toute paire de sommet il existe un chemin entre eux dans le graphe).

Description de l’algorithme

On utilise les tableaux suivants :

  • Distance[.] : Stocke la distance entre D (sommet de départ) et un autre sommet du graphe.
  • Father[.] : Stocke le sommet père d’un sommet du graphe parcouru.
  • Visite[.] : Stocke l’état de visite du sommet, liste des valeurs possible 0:pas encore visité,1:Visite en cours,2:Visité

On utilise les fonctions suivantes pour une file F :

  • First(F) : Retourne l’élément en tête de la file F sans le supprimer.
  • Dequeue(F) : Retourne l’élément en tête de la file F en le supprimant.
  • Append(F, A) : Mettre l’élément A dans la file F en queue de la file.

Les étapes de l’algorithme :

  • Phase d’initialisation
    • 1. Pour tous les sommets faire
      • Visite = 0 (Pas encore visité)
      • Pere = null (Initialise le tableau)
      • Distance = -1
    • 2. Append(F,D) (ajoute l’élément de départ)
    • 3. Distance[R] = 0 (postulat de départ)
  • Phase d’action (parcours du graphe G)
    • Tant que la file F n’est pas vide
      • t = First(F)
      • Pour tous les voisins v de t faire
        • Si Visite[v] = 0 (sommet non visité) alors
          • Visite[v] = 1 (Visite en cours)
          • Distance[v] = Distance[t] + 1
          • Father[v] = t
          • Append(F,v)
      • Dequeue(F)
      • Visite[t] = 2

Si on détaille les étapes avec le cas du graphe exemple ci-dessous.

Phase d’initialisation :

Implémentation des graphes en python par l'exemple : Le parcours en largeur python d'un graphe, algorithme utilisé pour parcourir les graphes.

Initialisation l’élément A est l’élément de départ à distance 0, il est coloré en orange pour indiquer que la visite est en cours.

Visite des voisins du sommet A (Visite du sommet B)

Parcours en largeur Python - Algorithme sur les Graphes
Le sommet B passe à en cours de visite, sa distance de A est calculée et le sommet A est ajouté comme sommet père. Il est ajouté à la file.

implémentation des graphes en python – Visite des voisins du sommet A (Visite du sommet C)

Implémentation des graphes en python par l'exemple : Le parcours en largeur python d'un graphe, algorithme utilisé pour parcourir les graphes.
Le sommet C passe à en cours de visite, sa distance de A est calculée et le sommet A est ajouté comme sommet père. Il est ajouté à la file.

Marquage de A comme visité et suppression de la file

Parcours en largeur Python - Algorithme sur les Graphes
A est marqué comme visité (couleur bleue) et retiré de la tête de la file

Visite des voisins du sommet B (Visite du sommet D)

Le sommet C etant marqué comme en cours de visite il ne sera pas visité, on visite le sommet D on calcule sa distance = 2 et on note le sommet B comme père du sommet B.

Marquage de B et C comme visité et suppression de la file

B est marqué comme visité (couleur bleue) et retiré de la tête de la file
C est marqué comme visité (couleur bleue) et retiré de la tête de la file (son voisin D est marqué en cours de visite)

Marquage de D comme visité et fin de l’algorithme

D est marqué comme visité (couleur bleue) et retiré de la tête de la file.
Fin de l’algorithme

Construction de l’arbre couvrant si le graphe est connexe

Si le graphe est connexe on déplie le résultat du parcours et on obtient l’arbre couvrant du graphe qui contient tous les sommets.

Application : Le parcours en largeur d’un graphe (BFS) est utile pour :

  • Vérifier si un graphe est connexe (tous les sommets sont alors marqués comme visités à la fin de l’algorithme).
  • Calculer les distances à partir d’un sommet donné
  • Construire un arbre couvrant du graphe
from collections import deque
def bfs(graph, vertex):
    queue = deque([vertex])
    distance = {vertex: 0}
    pere = {vertex: None}
    while queue:
      t = queue.popleft()
      for voisin in graph[t]:
        if voisin not in distance:
          queue.append(voisin)
          distance[voisin] = distance[t] + 1
          pere[voisin] = t
    return distance, pere
#Liste d'ajacence du graphe
graph = {
  'A': ['B','C'],
  'B': ['A','C', 'D'],
  'C': ['D'],
  'D': ['C','A']
}
distance,pere = bfs(graph,'A')
print("Distances" + str(distance))
print("Pere = " + str(pere))

Parcours en largeur python – Liens externes

https://fr.wikipedia.org/wiki/Python_(langage)

https://www.python.org/

https://fr.wikipedia.org/wiki/Algorithme_de_parcours_en_largeur

Implémentation des graphes en python – Liens internes

http://128mots.com/index.php/category/python/

http://128mots.com/index.php/2021/01/21/algorithme-glouton-python/

Installer kubernetes mac os x – Tutorial kubernetes débutant

Kubernetes mac os x, voici des explications pour installer facilement kubernetes sur son mac.

Kubernetes, ou k8s, est une plate-forme open source, lancée par Google, qui a commencé comme un simple outil d’orchestration de conteneurs mais est devenue une plate-forme native pour le cloud.

Installer kubernetes mac os x

Introduction – installer kubernetes mac

Sur mac os x une des méthodes les plus rapide pour installer Kubernetes est d’utiliser HoweBrew (voir le lien : Homebrew). Homebrew est un système de gestion de progiciels gratuit et open source qui simplifie l’installation de logiciels sur le système d’exploitation mac OS x Apple.

J’ai démarrer une console et executé la commande :

brew install kubectl

Vous devriez obtenir une sortie du type :

==> Pouring kubernetes-cli-1.20.2.catalina.bottle.tar.gz
==> Caveats
zsh completions have been installed to:
  /usr/local/share/zsh/site-functions
==> Summary
🍺  /usr/local/Cellar/kubernetes-cli/1.20.2: 246 files, 46.1MB

A la fin de l’installation vous pouvez vérifier que kubernetees est bien installer :

kubectl version --client
kubectl version --client
Client Version: version.Info{Major:"1", Minor:"20", GitVersion:"v1.20.2", GitCommit:"faecb196815e248d3ecfb03c680a4507229c2a56", GitTreeState:"clean", BuildDate:"2021-01-14T05:14:17Z", GoVersion:"go1.15.6", Compiler:"gc", Platform:"darwin/amd64"}

Vous pouvez également installer autocomplétion de shell : kubectl fournit un support d’auto-complétion pour Bash et Zsh :

brew install bash-completion@2

Ensuite :

export BASH_COMPLETION_COMPAT_DIR="/usr/local/etc/bash_completion.d"
[[ -r "/usr/local/etc/profile.d/bash_completion.sh" ]] && . "/usr/local/etc/profile.d/bash_completion.sh"

Activation de l’autocomplétion :

Lancez les commandes suivantes :

echo 'source <(kubectl completion bash)' >>~/.bashrc
kubectl completion bash >/usr/local/etc/bash_completion.d/kubectl
echo 'alias k=kubectl' >>~/.bashrc
echo 'complete -F __start_kubectl k' >>~/.bashrc

Installer Minikube :

minikube est un Kubernetes local qui vise à faciliter l’apprentissage et le développement pour Kubernetes.

J’ai lancé les commandes :

brew install minikube

Liens externes :

https://minikube.sigs.k8s.io/docs/start/

https://kubernetes.io/fr/docs/tasks/tools/install-kubectl/

Liens internes installer kubernetes mac :

http://128mots.com/index.php/2021/01/28/qiskit-textbook-qiskit-tutorial-algorithme-quantique-programmation/

http://128mots.com/index.php/category/python/

Qiskit textbook : tutorial d’algorithme quantique en Python

Je rappelle ici quelques concepts que nous allons utiliser dans notre algorithme de tri quantique, aussi je vous conseille de consulter le site IBM Qiskit pour en savoir plus sur le qiskit textbook https://qiskit.org.

Circuits dans Qiskit :

Le principe en algorithme quantique est de manipuler des qubits, le processus peut être représenté sous forme de circuit (entrées à gauche, sortie à droite). Nous pouvons effectuer différentes opérations au moyen de portes quantiques (qui agissent sur les qubits de manière similaire en algorithme classique aux portes logiques comme ET, OU, OU Exclusif …).

Dans cet article je vais m’appuyer sur Qiskit qui est le framework IBM pour l’informatique quantique.

from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from numpy import pi
qreg_qubit = QuantumRegister(2, 'qubit')
creg_classic = ClassicalRegister(2, 'classic')
circuit = QuantumCircuit(qreg_qubit, creg_classic)
circuit.reset(qreg_qubit[0])
circuit.reset(qreg_qubit[1])
circuit.x(qreg_qubit[0])
circuit.measure(qreg_qubit[0], creg_classic[0])
circuit.measure(qreg_qubit[1], creg_classic[1])

Dans ce premier algorithme on initialise un registre quantique à l’état |01> . On mesure dans un registre classique à 2 bits l’état quantique d’un registre quantique de 2 qubits. Le circuit peut être dessiné au moyen de l’instruction circuit.draw() ou via Circuit Composer de IBM Quantum Experience : https://quantum-computing.ibm.com/

qiskit tutorial python quantique algorithme quantum IBM

Etat quantique d’un qubit seul :

L’état d’un qubit peut s’exprimer sous la forme d’un vecteur d’état si on passe en forme trigonométrique et exponentielle on a avec θ and ϕ qui sont des nombres réels :

    \[|q\rangle = \cos{(\tfrac{\theta}{2})}|0\rangle + e^{i\phi}\sin{\tfrac{\theta}{2}}|1\rangle\]

Avec alpha et beta qui sont des nombres complexes (c’est à dire une partie réelle et imaginaire) dans ce cas il existe la relation (rappel mathématique sur les nombres complexes : https://www.maths-cours.fr/cours/nombres-complexes-geometrie/)

    \[|\psi\rangle = \alpha|0\rangle + \beta|1\rangle\]

    \[\sqrt{|\alpha|^2 + |\beta|^2} = 1\]

Ainsi si on mesure un qubit q on a :

    \[|q\rangle = \alpha|0\rangle + \beta|1\rangle\]

C’est à dire qu’il existe une probabilité de mesurer le qubit dans l’état |0> et une probabilité de mesurer le qubit dans l’état |1>. La mesure d’un qubit révèle si celui-ci est dans l’état 1 ou dans l’état 0, en général la mesure est placée en fin de circuit car elle affecte l’état du qubit en conséquence.

Qiskit tutorial et Qiskit textbook – Liens internes :

http://128mots.com/index.php/2021/01/26/ordinateur-quantique-prix/
http://128mots.com/index.php/2021/01/13/algorithme-tri-quantique/

http://128mots.com/index.php/2021/01/13/algorithme-tri-quantique/