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, …
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
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 :
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 :
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]))
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]))
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.
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.
Field
Description
Size
version
Version
4
Hash du bloc précédent
256-bit hash du block précédent
32
Merkle root
Il 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
time
Un timestamp numérique qui représente le nombre de seconde depuis 1970-01-01T00:00 UTC
4
bits
La cible actuelle (Current target) en format compacté
4
nonce
32-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 :
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) :
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 :
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)
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)
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
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))
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.
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 :
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/
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 :
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 :
![\[|q\rangle = \cos{(\tfrac{\theta}{2})}|0\rangle + e^{i\phi}\sin{\tfrac{\theta}{2}}|1\rangle\]](http://128mots.com/wp-content/ql-cache/quicklatex.com-3451da2a6973004892db316ab0e4c4b5_l3.png "Rendered by QuickLaTeX.com")
![\[|\psi\rangle = \alpha|0\rangle + \beta|1\rangle\]](http://128mots.com/wp-content/ql-cache/quicklatex.com-7e747384beff7d1e7dc0cba6ffef5a61_l3.png "Rendered by QuickLaTeX.com")
![\[\sqrt{|\alpha|^2 + |\beta|^2} = 1\]](http://128mots.com/wp-content/ql-cache/quicklatex.com-140825f90910f1016720805cd1c30596_l3.png "Rendered by QuickLaTeX.com")
![\[|q\rangle = \alpha|0\rangle + \beta|1\rangle\]](http://128mots.com/wp-content/ql-cache/quicklatex.com-e6a52fa4681f8adee60399c34542b89c_l3.png "Rendered by QuickLaTeX.com")