kleine Mathe-Spielereien

mit matplotlib, NumPy, pandas, SciPy, SymPy und weiteren mathematischen Programmbibliotheken.
OSWALD
User
Beiträge: 332
Registriert: Freitag 18. März 2022, 17:32

1.2.2024
Korrelation und Regression stehen in einem
engen Zusammenhang.
Man kann sagen: Die Korrelation überprüft die
Plausibilität der Ergebnisse aus der Regression.
Hier ein erstes Prgramm mit der linearen Regression
OSWALD

Code: Alles auswählen

#           y=a+b⋅x.
#           a    =      y-Achsenabschnitt (oder  intercept)
#           b    =      die Steigung der Regressionsgeraden.(slope)
#

import scipy
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import linregress

# create some random data
x = np.linspace(-10,10,11)

b = 10                #   Steigung(slope)
a =  4                 #    y-Achsenabschnitt  oder intercept 
y =  a+ b*x

# add some noise to data
y_len=y.shape[0]
noise = np.random.rand(y_len)*3
y = y +  noise

result = linregress(x, y)
slope = result.slope
print(slope)
intercept = result.intercept
y_hat = slope*x + intercept
 
plt.scatter(x,y,color="green")
plt.plot(x,y_hat,color="red")
plt.xlabel("X")
plt.ylabel("Y")
plt.title("Lineare Regression")
plt.grid(True)  
plt.show()
OSWALD
User
Beiträge: 332
Registriert: Freitag 18. März 2022, 17:32

1.2.2024
Wozu dient die lineare Regression .
Beispiel für die infache lineare Regression?
Wie hängt die Körpergröße mit dem Gewicht einer einer Person zusammen ?

Beispiel: multiple lineare Regression
Haben Körpergröße u n d Geschlecht einen Einfluss auf das Gewicht einer Person?
Hier ein weiteres Beispiel.
Neben
linearen gibt es auch noch nichtlineare Regressionsanalysen.
Statt einer Geraden-Gleichung haben wir es aber mit Kurven zu tun.
Auch dafür folgt ein Beispiel.
In der Profiwelt hat man heute Differentialgleichungen im Einsatz, was
weit über meine Möglichkeiten hinaus geht.
OSWALD

Code: Alles auswählen


import numpy as np
from scipy import stats
import matplotlib.pyplot as plt
x = np.linspace(-10, 50 ,num=50)
y = x + np.random.normal(size=x.size)
y[11:15] += 10                             # Ausreißer, starke Abweichung vom Mittelwet 
y[-5:] -= 7
#Compute the slope and intercept. For comparison,
#also compute the least-squares fit with linregress:

res = stats.siegelslopes(y, x)
print(res)
print()
lsq_res = stats.linregress(x, y)
print(lsq_res)
#Plot the results. The Siegel regression line is shown in red. The green line shows the least-squares fit for comparison.

fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot(x, y, 'b.')
ax.plot(x, res[1] + res[0] * x, 'r-')
ax.plot(x, lsq_res[1] + lsq_res[0] * x, 'g-')
plt.show()

OSWALD
User
Beiträge: 332
Registriert: Freitag 18. März 2022, 17:32

12.2024
Hier nun zwei Versionen von nicht -linearen
Regressionen. ZumThema Statistik wäre noch viel
mehr zu sagen.
Mir ist wichtig, dass ich mich etwas einarbeiten konnte.
Aber Python bietet so unermesslich viele andere Themen, die
mic alle noch interessieren würden.
OSWALD

Code: Alles auswählen






#           Regression mit quadratischer  Funktion

import matplotlib.pyplot as plt
from scipy.optimize import curve_fit
import numpy as np 
 # Erzeugung der Daten
np.random.seed(1356689)
x = np.linspace(-10, 10, num=50)
y = 2.0 + 1.5 * x + 3.0 * x**2 + np.random.normal(scale=3.0, size=x.shape)

num= 50        # Anzahl der Punkte

#  Die Modell-Funktion
def quadratic_func(x, a, b, c):
    return a - b * x + c * x**2

#  Die Funktion  enhält     drei Pratmeter:
#                       a  = Abschnitt auf der Y-Achse
#                       b   = slope (Diff.Quotient) 
#,                      c     gibt   vorhergesagten Wert zurück

#  Anpassung des  nichl-tinearen  Modells    
popt, pcov = curve_fit(quadratic_func, x, y)
print(popt)
print(pcov)
print()
  
# Visualize the results
plt.scatter(x, y, label='Data')
plt.plot(x, quadratic_func(x, *popt), 'r-', label='Fit')
plt.legend()
plt.title("Einfache nicht-lineare Regressioin")
plt.grid()
plt.show()


##################
# Regression  mit  Cubischer Fukmtion
##################
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit
 
np.random.seed(135566780)
x = np.linspace(-10, 10, num=30)
y = 2.0 + 1.5 * x -  3.0 * x**2 + np.random.normal(scale=3.0, size=x.shape)
num = 30 
def quadratic_func(x, a, b, c):
    return a + b * x - c * x**2


popt, pcov = curve_fit(quadratic_func, x, y)
print(popt )
print(pcov) 

plt.scatter(x, y, label='Data')
plt.plot(x, quadratic_func(x, *popt), 'r-', label='Fit')
plt.legend()
plt.title("Einfache nicht-lineare Regressioin")
plt.grid()

plt.show()

#################################



OSWALD
User
Beiträge: 332
Registriert: Freitag 18. März 2022, 17:32

6.2.2024
Wie angekündigt habe ich mich intensiv mit der
Logistischen Regression befasst.
Es handelt sich um ein sehr kompliziertes Thema und es gibt
diverse Arten von sog. L-Regressionen.ich beschränke
mich auf die Logistik Funktion (Sigma-F.
Hier eine erste vis.Darstellung)
OSWALD

Code: Alles auswählen


#nichtlineare regression

import numpy as np
import matplotlib.pyplot as plt
def logistic(x):
    return 1 / (1 + np.exp(-x))
# logistische Funktion plotten
t = np.arange(-10,10,0.1 )
#print(t)


plt.plot(t, logistic(t))
plt.yticks([ 1.0, 0.2, 0.5, 0.8, 1])
plt.grid(linewidth=1)
plt.title("Logistische Funktion")
plt.xlabel("Variable 't'")
plt.ylabel("Wahrscheinlichkedit  in %      von  NULL bis 1")
 
plt.grid(1)
plt.show()

OSWALD
User
Beiträge: 332
Registriert: Freitag 18. März 2022, 17:32

6.2.2024
Hier etwas über die Mathematik der Sigma-Funktion,
was zum Verständnis von Regressionen sehr beitragen kann.
Im maschinellen Lernen ist die logistische Regr, ein
großes Thema
OSWALD

Code: Alles auswählen


Original Funktion von  Sigma (Logistik-Kurve)

#   Original-Funktion  und 1.Ableitung
def sigmoid(x):
    return 1 / (1 + np.exp(-x))
#1.Ableitung der Sigmoid-Kurve
def d_sigmoid(x):
    return sigmoid(x) * (1 - sigmoid(x))

############################# 
#                         Das Python-Programm
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt


# Daten erzeugen
x = np.linspace(-10, 10, 100)            # hier x  =  100

# die  sigmoid - Daten 
y = sigmoid(x)   
#print(y)
# erste Ableitung
d = d_sigmoid(x)
#print(d)

#Mit Pandas erstellen wir einen Datenrahmen für die Daten,
#damit sie in einer Tabelle leicht sichtbar sind:
df = pd.DataFrame({"x": x, "sigmoid(x)": y, "d_sigmoid(x)": d})
print(df)

#Daten visualisieren:

plt.style.use("dark_background")
fig = plt.figure(figsize=(16, 9))

plt.plot(x, y, c="lightgreen", linewidth=3.0, label="$\sigma(x)     Logistik-Kurve    $")
plt.plot(x, d, c="lightblue", linewidth=3.0, label="$\\frac{d}{dx} \sigma(x) 1.Ableitung    $")

plt.legend(prop={'size': 20})
plt.show()


OSWALD
User
Beiträge: 332
Registriert: Freitag 18. März 2022, 17:32

Die oben gezeigte Sigmoid-Kurve mit Ableitung der Funktion
ist die Grundlage für diverse Modelle zur Berechnung
logistischer Regression.
F = 1/ 1+ e**t

Die Sigmoid_Funktion hat große Bedeutung
in der Statistik und auch in den 'Neuronalen Netzen'
Die analytischen Auswertungen der Funktion sind
umfassend voneinfachen Gleichungen bis zuDifferenzialgleichungen,
wo auch die Ableitungen eine große Rolle spielen.
Das alles aber geht über meine Möglichkeiten hinaus.
Noch eine Bemerkung tur bleitung:
Mit scipy ist eine Ableitung nicht moglich, auch nicht mit sympy.
Speziell iese Ableitung kann nur mit der Kettenregel erfolgen.

Dafür ein kleines Beispiel , das ich unten über Python berechne.

Eine Schule hat insgesamt 3.000 Schülerinnen und Schüler.
Ein Schüler hat die Grippe bekommen und bleibt nicht zuhause.
Wir gehen davon aus, dass keiner der Schüler Grippeimpfungen bekommen hat
und alle anfällig für für das Virus sind.

Die Ausbreitung des Virus folgt einer logistischen Kurve,
die durch folgende Formel beschrieben wird:
wobei P die Anzahl der Personen ist,
die sich infiziert haben und t die Anzahl der Tage ist.
Wie viele Menschen haben sich nach 10 Tagen infiziert?

Und hier das Wachstumsmodell:

P(t) = C / 1 + e**(b*t)

Konkret P(10) = 3000 /( 1+ 2999 * e**(0.4 *10))

wobei c= Gesamtschülerzahlt
t = Tage
b = Wachstumsfaktor
########################################

Code: Alles auswählen

#Beispielrechnung
import math
import numpy as  np

def wachstum_func(b,t,c):
    c=0
    b=0.40
    t=10
wachstum_func =   3000 / ( 1+ 2999 *np.e **(-0.401 *10))
print("Zahl  der Infizierten in 10 Tagen  :",wachstum_func)

OSWALD
User
Beiträge: 332
Registriert: Freitag 18. März 2022, 17:32

10.2.2024
Mit diesem kleinen Programm achließe ich (vorläufig)
das Thema Statistik ab..
Ich werde mich nun dem Thema "Graphen und Netzwerk" zuwenden.
Was daraus wird, dürfte sich erst nach einiugen Wochen harausstellen.
Ich weiß nur, dass ich meine gesamten Python-Kenntnisse
brauchen werde. Das 'Modul re' hat sich schon angemeldet.
Gute Zeit OSWALD

Code: Alles auswählen

#Einsatz  der  Logistik-Funktion  als 'Genesungsrate'


#  Wieviele  von 3000  an Grippe  Erkrankte  können bei einer Heilungsrate
#  von 0,4  in    20 Tagen  genesen ?

#Daazu  nächste   Aufgabe: Wie hoch ist die Heilungsrate,
#wenn  in 7 Tagen   etwa 16 Erkrankte  geheilt  sind. ########################################
#(Hinweis. die Funktion ist nicht linear) 



#Beispielrechnung
import math
import numpy as  np

def wachstum_func(b,t,c):
    c=0
    b=0.40
    t=100
wachstum_func =   3000 / ( 1 + 2999 *np.e **(-0.401 * 7))
print("Zahl  der Infizierten in 10 Tagen  :",wachstum_func)













OSWALD
User
Beiträge: 332
Registriert: Freitag 18. März 2022, 17:32

23.2.2024
'Graphen und Networkx'
ist das Thema , dem ich ich zugewendet h habe.
Mein erster Eindruck war: 'ich stehe im Wald'.
aber bald gewann ich Durchblick und die
Begriffe zu sortieren:
Ein Graph ist ein Konzept der
Mathematik und ein Grundbegriff der mathematischen Graphentheorie.
Zugleich werden Graphen intensiv in der Informatik genutzt, z.B. als abstrakte Datenstruktur
(wie eine Liste oder ein Dictionary), mit der sich bestimmte Probleme besser bzw. überhaupt erst lösen lassen.

Die mathematische Definition eines Graphen lautet:
Ein Graph G ist ein Triple bestehend aus einem Set von Knoten V(G),
einem Set von Kanten E(G),
und einer Beziehung, die mit jeder Kante zwei Knoten verbindet,
die deren Endpunkte genannt werden.

Graphen werden visualisiert, indem man die Knoten als Punkte zeichnet
und die Kanten als verbindende Linien. Wir reden hier nur über endliche Graphen,
bei denen die Mengen V(G) und E(G) endlich sind.

Die Endpunkte einer Kante können identisch sein (= derselbe Knoten), dann handelt es sich um eine Schleife (loop).
Es gibt Graphen mit multiplen Kanten,
d.h. zwei Kanten können dieselben Endpunkte haben.

Ein simpler Graph hat weder Schleifen noch multiple Kanten.
Ein Multigraph dagegen weist sowohl Schleifen als auch multiple Kanten auf.
In einem Digraph oder auch gerichteten Graphen sind die Kanten gerichtet,
können also nur in einer Richtung durchlaufen werden.

Und nun kann ich konkret in ' medias in res' einsteigen.
Zunächst zeige ich die KlASSE Graph.
Mit weiteren Visualisierungen versuche ich
mir zumindest einen Überblick über dieses allgegenwärtige
Konzept zu verschaffen
Gute Zeit OSWALD

Code: Alles auswählen

"" A Python Class
A simple Python graph class, demonstrating the essential 
facts and functionalities of graphs.
"""


class Graph(object):

    def __init__(self, graph_dict={}):
        """ initializes a graph object """
        self.__graph_dict = graph_dict

    def vertices(self):
        """ returns the vertices of a graph """
        return list(self.__graph_dict.keys())

    def edges(self):
        """ returns the edges of a graph """
        return self.__generate_edges()

    def add_vertex(self, vertex):
        """ If the vertex "vertex" is not in 
            self.__graph_dict, a key "vertex" with an empty
            list as a value is added to the dictionary. 
            Otherwise nothing has to be done. 
        """
        if vertex not in self.__graph_dict:
            self.__graph_dict[vertex] = []

    def add_edge(self, edge):
        """ assumes that edge is of type set, tuple or list; 
            between two vertices can be multiple edges! 
        """
        edge = set(edge)
        (vertex1, vertex2) = tuple(edge)
        if vertex1 in self.__graph_dict:
            self.__graph_dict[vertex1].append(vertex2)
        else:
            self.__graph_dict[vertex1] = [vertex2]

    def __generate_edges(self):
        """ A static method generating the edges of the 
            graph "graph". Edges are represented as sets 
            with one (a loop back to the vertex) or two 
            vertices 
        """
        edges = []
        for vertex in self.__graph_dict:
            for neighbour in self.__graph_dict[vertex]:
                if {neighbour, vertex} not in edges:
                    edges.append({vertex, neighbour})
        return edges

    def __str__(self):
        res = "vertices: "
        for k in self.__graph_dict:
            res += str(k) + " "
        res += "\nedges: "
        for edge in self.__generate_edges():
            res += str(edge) + " "
        return res


if __name__ == "__main__":

    g = { "a" : ["d"],
          "b" : ["c"],
          "c" : ["b", "c", "d", "e"],
          "d" : ["a", "c"],
          "e" : ["c"],
          "f" : [] ,
          "z" :[]
        }


    graph = Graph(g)

    print("Vertices of graph:")
    print(graph.vertices())

    print("Edges of graph:")
    print(graph.edges())

    print("Add vertex:")
    graph.add_vertex("z")

    print("Vertices of graph:")
    print(graph.vertices())
 
    print("Add an edge:")
    graph.add_edge({"a","z"})
    
    print("Vertices of graph:")
    print(graph.vertices())

    print("Edges of graph:")
    print(graph.edges())

    print('Adding an edge {"x","y"} with new vertices:')
    graph.add_edge({"x","y"})
    print("Vertices of graph:")
    print(graph.vertices())
    print("Edges of graph:")
    print(graph.edges())
OSWALD
User
Beiträge: 332
Registriert: Freitag 18. März 2022, 17:32

23.2.2024
Wie kann man sich als Anfänger einem so
komplexen System wie der Graphen-Theorie
nähern ? Nach meiner bisherigen Erfahrung am besten
über die visuelle Darstellung von konkreten Beispielen in Python.
Knoten und Kanten sind jeweils mit diversen Eigenschaften oder
Argumenten ausgestattet, mit denen man sich
nach und nach vertraut machen kann.
eIn erstes Beispiel
Oswald

Code: Alles auswählen


#     Erstellung     und  Visualisierung  eines Graphen
import matplotlib.pyplot as plt
import networkx as nx

#G = nx.grid_2d_graph(4, 4)                # Beliebige Form , Zahl von Ecken und Knoten 
#G = nx.grid_2d_graph(1, 5)
G = nx.grid_2d_graph(2,3 )
print(G) 
# print the adjacency list
for line in nx.generate_adjlist(G):
    print(line)
# write edgelist to grid.edgelist
nx.write_edgelist(G, path="grid.edgelist", delimiter=" :")
# read edgelist from grid.edgelist
H = nx.read_edgelist(path="grid.edgelist", delimiter=":")
print(H)
pos = nx.spring_layout(H, seed=200)
nx.draw(H, pos)
plt.show()







OSWALD
User
Beiträge: 332
Registriert: Freitag 18. März 2022, 17:32

23.2.2024
Das Studium einzelner Visualisierungen
von Graphen führt schnell zum Lewrnziel
Oswald

Code: Alles auswählen

# Jeder Knoten mit einem anderen Knoten verbunden  =   'vollständiger Graph'


import networkx as nx
import matplotlib.pyplot as plt
#Anzahl der Knoten ,hier 10)
G = nx.complete_graph(10)
nx.draw_circular(G, with_labels=True, font_weight='bold')
plt.show()

############################################
# Kanten ungerichtet und gerichtet ,  diverse weitere  Eigenschaften
import networkx as nx
import matplotlib.pyplot as plt

G = nx.Graph()
G.add_edge(1, 2)
G.add_edge(1, 3)
G.add_edge(1, 5)
G.add_edge(2, 3)
G.add_edge(3, 4)
G.add_edge(4, 5)
G. add_edge(5,6)
# explicitly set positions
pos = {1: (0, 0), 2: (-1, 0.3), 3: (2, 0.17), 4: (4, - 0.255), 5: (5, 0.03), 6:(6, -0.28 )}

options = {
    "font_size": 16,
    "node_size": 3000,
    "node_color": "red",
    "edgecolors": "black",
    "linewidths": 2,
    "width": 3,
}
nx.draw_networkx(G, pos, **options)

# Set margins for the axes so that nodes aren't clipped
ax = plt.gca()
ax.margins(0.20)
plt.axis("on")
plt.show()
 

G = nx.DiGraph([(0, 3), (1, 3), (2, 4), (3, 5), (3, 6), (4, 6), (5, 6)])

# group nodes by column
left_nodes = [0, 1, 2]
middle_nodes = [3, 4]
right_nodes = [5, 6]

# set the position according to column (x-coord)
pos = {n: (0, i) for i, n in enumerate(left_nodes)}
pos.update({n: (1, i + 0.5) for i, n in enumerate(middle_nodes)})
pos.update({n: (2, i + 0.5) for i, n in enumerate(right_nodes)})

nx.draw_networkx(G, pos, **options)

# Set margins for the axes so that nodes aren't clipped
ax = plt.gca()
ax.margins(0.20)
plt.axis("off")
plt.show()

OSWALD
User
Beiträge: 332
Registriert: Freitag 18. März 2022, 17:32

25.2.2024
Zum Sonntag:
Kleine Mathe-Spielerei.
Veränderiung einer Graph-Animation durch
Austausch einer Variablen T gegen T**1/2
Einmal Knoten und Kannten aals Graph, dann Knoten im Käfig.
Gute Zeit OSWALD

Code: Alles auswählen

import numpy as np
import networkx as nx
import random
import matplotlib.pyplot as plt
from matplotlib import animation
#Define a graph to plot.
#Pick up a graph to look good in 3D.

G = nx.dodecahedral_graph()                                    #  zwölfeckGRAPH
pos = nx.spectral_layout(G, dim=3)
nodes = np.array([pos[v] for v in G])
edges = np.array([(pos[u], pos[v]) for u, v in G.edges()])
#Rotating 3#D graph animation.
#In this example, a frame update is only a rotation of a given 3D graph.

def init():
    ax.scatter(*nodes.T**1/2, alpha=0.2, s=100, color="blue")                     # hier  T gegen  T**1/2   tauschen
    for vizedge in edges:
        ax.plot(*vizedge.T, color="red")
    ax.grid(False)
    ax.set_axis_off()
    plt.tight_layout()
    return


def _frame_update(index):
    ax.view_init(index * 0.2, index * 0.5)
    return


fig = plt.figure()
ax = fig.add_subplot(111, projection="3d")

ani = animation.FuncAnimation(
    fig,
    _frame_update,
    init_func=init,
    interval=10,
    cache_frame_data=False,
    frames=120
)
plt.show()


OSWALD
User
Beiträge: 332
Registriert: Freitag 18. März 2022, 17:32

25.2.2024
Die nächste kleine Veränderung von an T (Teilmenge von Bipartite-Grlph ).
Graph und Netzwerk sind keineswegs nur trockene Thorie.
Etwa in der Chemie spielt die Graphentheorie speziell in der Strukturermittelung
von Verbindungen z.B. der Fulklerene, eine sehr große Rolle
Oder: die Max-Plamkgeselleschft hat auf eine neue Endeckung hingewiesen:
Verschränkung und Graphenteorie führten zusammen zu bedeutenden Regebnissen.
Gute Zeit OSWALD

Code: Alles auswählen

mport numpy as np
import networkx as nx
import random
import matplotlib.pyplot as plt
from matplotlib import animation
#Define a graph to plot.
#Pick up a graph to look good in 3D.

G = nx.dodecahedral_graph()                                    #  zwölfeckGRAPH
pos = nx.spectral_layout(G, dim=3)
nodes = np.array([pos[v] for v in G])
edges = np.array([(pos[u], pos[v]) for u, v in G.edges()])
#Rotating 3#D graph animation.
#In this example, a frame update is only a rotation of a given 3D graph.

def init():
    ax.scatter(*nodes.T**1/2, alpha=0.2, s=100, color="blue")  # T gegen  T**1/2   tauschen
    ax.scatter(*nodes.T**1/3 , alpha=0.2, s=100, color="green") 
    for vizedge in edges:
        ax.plot(*vizedge.T, color="red")
    ax.grid(False)
    ax.set_axis_off()
    plt.tight_layout()
    return


def _frame_update(index):
    ax.view_init(index * 0.2, index * 0.5)
    return


fig = plt.figure()
ax = fig.add_subplot(111, projection="3d")

ani = animation.FuncAnimation(
    fig,
    _frame_update,
    init_func=init,
    interval=10,
    cache_frame_data=False,
    frames=120
)
plt.show()









OSWALD
User
Beiträge: 332
Registriert: Freitag 18. März 2022, 17:32

27.2.2024
Jetzt werden Adjanz(Nachbar)-Matrizen erstellt.
Je nach der Kanten-Anordnung und ob gewichtet oder ungwrichet,
fallen die Adjanzmatrizen unterschiedlich aus.
Umgekehrt können aus vorliegenden Adjanz-Matrizen auch
daraus wieder Graphen erstellt werden.(richtig verstanden ?)
Gute zeit OSWALD

Code: Alles auswählen

#                 Adjanz-Matritzen in Abhängigkeit von der Kantenanordnung:
#                                            Adjanz = 'Nachbarschaft'
#                 Unterschiedliche Anordnungen der Kanten , gewchet nd ungewichtet   
row_num = 6
col_num = 6
adjacency_matrix = []
for i in range(row_num):
    row = []
    for j in range(col_num):
        row.append(0)
    adjacency_matrix.append(row)
edges = [(1, 2), (2, 5), (2, 3), (3, 4), (4, 5), (3, 6), (5, 6)]

#print(edges)
for edge in edges:
    row = edge[0]
    col = edge[1]
    adjacency_matrix[row - 1][col - 1] = 1
    adjacency_matrix[col - 1][row - 1] = 1
    print(edges)
print("Das sind ungewichtete  Kanten im Graph:")
print(edges)
print("Die Adanz-Matrix  bei dieser Kantenanordnung  sieht so aus:")     
pprint.pprint(adjacency_matrix)
print()
################################
  
import pprint
row_num = 6
col_num = 6
adjacency_matrix = []
for i in range(row_num):
    row = []
    for j in range(col_num):
        row.append(0)
    adjacency_matrix.append(row)
weighted_edges = [
    (1, 2, 5),
    (2, 4, 12),
    (2, 3, 2),
    (3, 4, 8),
    (4, 5, 7),
    (3, 6, 4),
    (5, 6, 2),
]
for edge in weighted_edges:
    row = edge[0]
    col = edge[1]
    weight = edge[1]
    adjacency_matrix[row - 1][col - 1] = weight
    adjacency_matrix[col - 1][row - 1] = weight

print("gewichtete Kanten:")
print(weighted_edges)
print("Aadjacenz-  Matrix :")
pprint.pprint(adjacency_matrix)
############################################ 
#############################################


import  pprint
import numpy as np

row_num = 6
col_num = 6
adjacency_matrix = np.zeros((row_num, col_num), dtype=int)
edges = [(1, 2), (2, 4), (2, 3), (3, 4), (4, 5), (3, 6), (5, 6)]
for edge in edges:
    row = edge[0]
    col = edge[1]
    adjacency_matrix[row - 1][col - 1] = 1
    adjacency_matrix[col - 1][row - 1] = 1

print("Das sind die Kanten ")
print(edges)
print("undx hier die Matrix:")
pprint.pprint(adjacency_matrix)
print() 
######################################
 
 
import pprint
import numpy as np

row_num = 6
col_num = 6
adjacency_matrix = np.zeros((row_num, col_num), dtype=int)
weighted_edges = [
    (1, 3, 5),
    (2, 4, 12),
    (2, 4, 1),
    (3, 4, 8),
    (4, 3, 7),
    (3, 6, 4),
    (5, 6, 2),
]
for edge in weighted_edges:
    row = edge[0]
    col = edge[1]
    weight = edge[2]
    adjacency_matrix[row - 1][col - 1] = weight
    adjacency_matrix[col - 1][row - 1] = weight

print("Gewichtete Kanten  im Graph")
print(weighted_edges)
print("Die Adjazmatrix sieht so aus:")
pprint.pprint(adjacency_matrix)

OSWALD
User
Beiträge: 332
Registriert: Freitag 18. März 2022, 17:32

28.2.2024r
Und hier wird ein graph mit gewichteten und gerichteten Kanten
erzeugt. Z u ubeachten ist dafür die Implementierung des
Digraphen.
Gute Zeit Oswald

Code: Alles auswählen

import networkx as nx
import matplotlib.pyplot as plt
G = nx.Graph()
G = nx.DiGraph(directed=True)
print(G)
G.add_edge('S', 'B', weight= 3)
G.add_edge('S', 'C', weight= 10)
G.add_edge('B', 'D', weight= 3)
G.add_edge('D', 'E', weight= 6)
G.add_edge('D', 'F', weight= 3)
G.add_edge('E', 'C', weight= 5)
G.add_edge('B', 'F', weight= 2)
G.add_edge('C', 'F', weight= 2)
G.add_edge('E', 'G', weight= 4)
G.add_edge('G', 'H', weight= 7)
G.add_edge('F', 'G', weight= 1)
G.add_edge('D', 'H', weight= 3)
print(G)
pos = nx.spring_layout(G, seed=5)
nx.draw(G, pos=pos, with_labels=True, node_color='yellow')
edge_labels = nx.get_edge_attributes(G,'weight')
nx.draw_networkx_edge_labels(G, pos, edge_labels);
plt.show()

OSWALD
User
Beiträge: 332
Registriert: Freitag 18. März 2022, 17:32

29.2.2024
Der Begriff "Inzidenz" ist spätestens seit Corona
allgemein bekannt.
Inzidenz spielt in der Statistik und auch in der
Graphentheorie eine große Rolle.
Sowohl für ungerichtete als auch für gerichtete Graphen
versuche ich jetzt ein Beispiel zu erstellen.
Hier zunächst der ungerichtete Graph .
mit der entsprechenden Inzidenz- Matrize und der
Inzidenz-Datei. (hoffentlich richtig)
Guten Tag OSWALD

Code: Alles auswählen

##### Ungerichteter Graph    mit  5x6   Inzidenz - Matrix
import networkx as nx
# importing matplotlib.pyplot
import matplotlib.pyplot as plt
 

g=nx.DiGraph()                                                        #  e1,e2,e3,e4,e5,e6
                                                      
g.add_edge(1,0)                    # 1    #  (1  0  0   0    1   1)     formales >Beispiel  für  Inzidenz-Matrix
g.add_edge(1,0)                     # 2     #  (1  1 0   0    0   1 )    und  für Tabelle
g.add_edge(1,0)                     # 3     #  (0  1 1   0    0   0 )
g.add_edge(1,0)                     # 4     #  (0  0  1  1    0   0 )
g.add_edge(1,1)                     #  5    #  (0  0  0  1   1   1  )
g.add_edge(1,0) 

g.add_edge(2,1)                           
g.add_edge(2,1)
g.add_edge(2,0)
g.add_edge(2,0) 
g.add_edge(2,0)
g.add_edge(2,1)
            
g.add_edge(3,0)
g.add_edge(3,1)
g.add_edge(3, 1)
g.add_edge(3,0 )
g.add_edge(3, 0)
g.add_edge(3,0 )                           

g.add_edge(4,0)
g.add_edge(4,0)
g.add_edge(4, 1)
g.add_edge(4,1 )
g.add_edge(4, 0)
g.add_edge(4,0 )

g.add_edge(5,0)
g.add_edge(5,0)
g.add_edge(5,0)
g.add_edge(5,1 )
g.add_edge(5, 1)
g.add_edge(5,1 )

nx.draw(g, with_labels = True)
plt.savefig("filename.png")
plt.show()


OSWALD
User
Beiträge: 332
Registriert: Freitag 18. März 2022, 17:32

29.2.24
Das war die falsche Datei
.Pardon. Jetzt kommt die richtige. Änderung
ODSWALD

Code: Alles auswählen

###### Ungerichteter Graph    mit  5x6   Inzidenz - Matrix
import networkx as nx
# importing matplotlib.pyplot
import matplotlib.pyplot as plt
 

g=nx.Graph()                          #  e1,e2,e3,e4,e5,e6      #Tausch g= nx.Graph gegen  g=nx.DiGraph
                                                      
g.add_edge(1,0)                    # 1    #  (1  0  0   0    1   1)     formales >Beispiel  für  Inzidenz-Matrix
g.add_edge(1,0)                     # 2     #  (1  1 0   0    0   1 )    und  für Tabelle
g.add_edge(1,0)                     # 3     #  (0  1 1   0    0   0 )
g.add_edge(1,0)                     # 4     #  (0  0  1  1    0   0 )
g.add_edge(1,1)                     #  5    #  (0  0  0  1   1   1  )
g.add_edge(1,0) 

g.add_edge(2,1)                           
g.add_edge(2,1)
g.add_edge(2,0)
g.add_edge(2,0) 
g.add_edge(2,0)
g.add_edge(2,1)
            
g.add_edge(3,0)
g.add_edge(3,1)
g.add_edge(3, 1)
g.add_edge(3,0 )
g.add_edge(3, 0)
g.add_edge(3,0 )                           

g.add_edge(4,0)
g.add_edge(4,0)
g.add_edge(4, 1)
g.add_edge(4,1 )
g.add_edge(4, 0)
g.add_edge(4,0 )

g.add_edge(5,0)
g.add_edge(5,0)
g.add_edge(5,0)
g.add_edge(5,1 )
g.add_edge(5, 1)
g.add_edge(5,1 )

nx.draw(g, with_labels = True)
plt.savefig("filename.png")
plt.show()

code]
OSWALD
User
Beiträge: 332
Registriert: Freitag 18. März 2022, 17:32

29.2.2024
Hier der Versuch mit einem
Gerichteten Graph mit einer 6x 4 Inzidenz-Matrix mit Tabelle
OSWALD

Code: Alles auswählen

##### Gerichteter Graph    mit 6x4   Inzidenz - Matrix
import networkx as nx
# importing matplotlib.pyplot
import matplotlib.pyplot as plt
 

g=nx.DiGraph()                       #  e1,e2,e3,e4,e5,e6
                                                      
g.add_edge(1,1)                    # 1    #  (1  0  -1   1   0   0)     formales >Beispiel  für  Inzidenz-Matrix
g.add_edge(1,0)                     # 2     #  (-1  1 0   0    1  0 )    und  für Tabelle
g.add_edge(1,-1)                     # 3     #  (0  1 1   0    0   ,-1 )
g.add_edge(1,0)                     # 4     #  (0  0   0   -1   -1   1 )
g.add_edge(1,0)                     
g.add_edge(1,0) 

g.add_edge(2,-1)                           
g.add_edge(2,1)
g.add_edge(2,0)
g.add_edge(2,0) 
g.add_edge(2,1)
g.add_edge(2,0)
            
g.add_edge(3,0)
g.add_edge(3,1)
g.add_edge(3, 1)
g.add_edge(3,0 )
g.add_edge(3, 0)
g.add_edge(3,-1 )                           

g.add_edge(4,0)
g.add_edge(4,0)
g.add_edge(4,0)
g.add_edge(4,-1 )
g.add_edge(4,- 1)
g.add_edge(4,1 )

 
nx.draw(g, with_labels = True)
plt.savefig("filename.png")
plt.show()



OSWALD
User
Beiträge: 332
Registriert: Freitag 18. März 2022, 17:32

1.3.2014
Abschließend zum Thema noch ein Beispiel,
das auf die Komplexität dieser Thematik hinweist.
Ich bin zufrieden, wenn ich den vorliegenden Code halbwegs verstehe.
Alles Weitere ist wohl eher der Mathematik vorbehalten
Gute Zeit OSWALD

Code: Alles auswählen


mport networkx as nx
G = nx.Graph()
 
# Adding one edge at a time
# Node 1 and 2 will be automatically added
G.add_edge(1,2)
G.add_edge(3,2)
print (G)
# Adding multiple edges at a time
G.add_edges_from([(4,2), (3,5), (5,4)])
 
# Adding duplicates will be ignored.
G.add_node(1)
G.add_edge(1,2)
 
print(G.nodes())
print(G.edges())
[1, 2, 3, 4, 5]
[(1, 2), (2, 3), (2, 4), (3, 5), (4, 5)]
 

import networkx as nx
G = nx.Graph()
 
# Creating graph
G.add_edges_from([(1, 2), (2, 3), (3, 4), (4, 1)])
G.add_edges_from([(5, 6), (5, 7), (5, 8), (7, 8)])
 
print(G.nodes())
print(G.edges())
 
# Removing edge 1-2 from graph
G.remove_edge(2, 1)
# Removing edge 3-4 and 1-4 at once
G.remove_edges_from([(3, 4), (1, 4)])
 
print()
print(G.nodes())
print(G.edges())
 
# Removing node 5 from graph
G.remove_node(5)
# Removing node 7 and 8
G.remove_nodes_from([7,8])
 
print()
print(G.nodes())
print(G.edges())
[1, 2, 3, 4, 5, 6, 7, 8]
[(1, 2), (1, 4), (2, 3), (3, 4), (5, 6), (5, 7), (5, 8), (7, 8)]
 
[1, 2, 3, 4, 5, 6, 7, 8]
[(2, 3), (5, 6), (5, 7), (5, 8), (7, 8)]
 
[1, 2, 3, 4, 6]
[(2, 3)]
 


import networkx as nx
 
G = nx.Graph()
 
G.add_edges_from([(1,2), (1,3), (3,4), (3,5)])
 
print("Nodes")
print(G.nodes)
print("Edges")
print(G.edges)
print("Adjacency List")
print(G.adj)
print("Degree")
print(G.degree)
 
print()
 
print("Adjacency List for node 3")
print(G.adj[3])
print("Degree for node 3")
print(G.degree[3])
 
[1, 2, 3, 4, 5]
 
[(1, 2), (1, 3), (3, 4), (3, 5)]
#Adjacency List
{1: {2: {}, 3: {}}, 2: {1: {}}, 3: {1: {}, 4: {}, 5: {}}, 4: {3: {}}, 5: {3: {}}}
#[(1, 2), (2, 1), (3, 3), (4, 1), (5, 1)]
 
#Adjacency List for node 3
{1: {}, 4: {}, 5: {}}
#3
#Jeder Graph, Knoten und jede Kante kann Schlüssel/Wert-Attributpaare
#

#Sie können dem Diagramm beim Erstellen Attribute zuweisen nx.Graph().

import networkx as nx
G = nx.Graph(graph_description = "This is an empty graph")
print(G.graph)
 


import networkx as nx
G = nx.Graph()
G.graph["description"] = "This is empty graph"
G.graph["data"] = 5
print(G.graph)
# Output: {'description': 'This is empty graph', 'data': 5}
#2. Knotenattribute
#
import networkx as nx
G = nx.Graph()
 
# Using add_node
G.add_node(1, data = "data1")
 
# Using add_nodes_from
G.add_nodes_from([(2, {"data": "data2"}),
                  (3, {"data": "data3"})], 
                   node_type = "child node")
 
# Adding more attributes on node 1 using G.nodes
G.nodes[1]["type"] = "root node"
 
print(G.nodes.data())
# Output: [(1, {'data': 'data1', 'type': 'root node'}), (2, {'node_type': 'child node', 'data': 'data2'}), (3, {'node_type': 'child node', 'data': 'data3'})]
 
print(G.nodes[1])
 

import networkx as nx
G = nx.Graph()
 
# Using add_edge
G.add_edge(1, 2, weight = 50)
 
# Using add_edges_from
G.add_edges_from([
                  (1, 3, {"weight": 70}),
                  (1, 4, {"weight": 100})
                ])
 
# Using subscript notation
G.add_edge(4,5)
G[4][5]["weight"] = 175
 
# Using G.edges
G.edges[1, 2]["weight"] = 10
 
print(G.edges.data())
 
# Output: [(1, 2, {'weight': 10}), (1, 3, {'weight': 70}), (1, 4, {'weight': 100}), (4, 5, {'weight': 175})]
#draw()Mit der gezeigten Methode können wir Diagramme zeichnen und sie im NetworkX-Paket visualisieren .

import networkx as nx
 
G = nx.Graph()
 
# Using add_edge
G.add_edge(1, 2, weight = 12.5)
G.add_edge(3, 2, weight = 50.0)
G.add_edge(1, 3, weight = 17)
G.add_edge(4, 2, weight = 100)
G.add_edge(2, 5, weight = 1)
G.add_edge(4, 6, weight = 25.5)
G.add_edge(7, 4, weight = 175)
G.add_edge(5, 8, weight = 90)
 
nx.draw(G, with_labels= True, font_weight='bold')
 
import networkx as nx
import matplotlib.pyplot as plt
 
G = nx.Graph()
 
# Using add_edge
G.add_edge(1, 2, weight = 12.5)
G.add_edge(3, 2, weight = 50.0)
G.add_edge(1, 3, weight = 17)
G.add_edge(4, 2, weight = 100)
G.add_edge(2, 5, weight = 1)
G.add_edge(4, 6, weight = 25.5)
G.add_edge(7, 4, weight = 175)
G.add_edge(5, 8, weight = 90)
 
 
pos=nx.circular_layout(G)
nx.draw(G, pos, with_labels=True, font_weight='bold')
edge_weight = nx.get_edge_attributes(G,'weight')
nx.draw_networkx_edge_labels(G, pos, edge_labels = edge_weight)
plt.show()
 
import networkx as nx
 
DG = nx.DiGraph()
DG.add_edges_from([(1,2), (2,3), (3,4), (4,5), (5,2), (4, 6)])
print(DG) 
# Print edges going out from node 4
print("Out edges of node 4 are:",DG.out_edges(4))
 
# Print in degree of node 2Predecessors
print("In Degree of node 2 is:",DG.in_degree(2))
 
# Print successors of node 4
print("Successors of node 4 are:",list(DG.successors(4)))
 
# Print predecessors of node 2
print("Predecessors of node 2 are:",list(DG.Predecessors(2)))
 
nx.draw(DG, with_labels= True, font_weight='bold')
#Out edges of node 4 are: [(4, 5), (4, 6)]

#Predecessors of node 2 are: [1, 5]
OSWALD
User
Beiträge: 332
Registriert: Freitag 18. März 2022, 17:32

2.3.2024
Terence Tao löst sie "fast"
Er konnte zeigen, dass die Collatz-Vermutung für natürliche Zahlen „fast zutrifft“. Das bedeutet, dass es eine sehr hohe, aber nicht 100-prozentige Wahrscheinlichkeit gibt, dass man die 421-Schleife erreicht.

2020 konnte man mithilfe eines Computers alle positiven Zahlen bis 2^68 bestätigen.05.01.2022 !!


Das Thema hat mich interessiert und wieder zu einer Spielerei verführt.
Ich wollte wissen wie weit ich mit meiner 8G-Maschine komme:
Also habe ich folgende Zahl eingesetzt;
1000000000000000012 .(17 Stellen)


Nach etwa 2 min war das positive Ergebnis da.
Es kann jetztJeder testen, was seine Maschine leistet
Viel Spaß beim Mathe-Spiel.
Gute Zeit OSWALD

Code: Alles auswählen


def collatz(n):
    while n > 1:
        print(n, end=' ')
        if (n % 2):
            # n is odd
            n = 3*n + 1
        else:
            # n is even
            n = n//2
    print(1, end='')
 
 
n = int(input('Enter n: '))
print('Sequence: ', end='')
collatz(n)
 
OSWALD
User
Beiträge: 332
Registriert: Freitag 18. März 2022, 17:32

2.3.2024
Und hier die Zahlen
Oswald


Enter n: 10000000000000000012
Sequence: 10000000000000000012 5000000000000000006 2500000000000000003 7500000000000000010 3750000000000000005 11250000000000000016 5625000000000000008 2812500000000000004 1406250000000000002 703125000000000001 2109375000000000004 1054687500000000002 527343750000000001 1582031250000000004 791015625000000002 395507812500000001 1186523437500000004 593261718750000002 296630859375000001 889892578125000004 444946289062500002 222473144531250001 667419433593750004 333709716796875002 166854858398437501 500564575195312504 250282287597656252 125141143798828126 62570571899414063 187711715698242190 93855857849121095 281567573547363286 140783786773681643 422351360321044930 211175680160522465 633527040481567396 316763520240783698 158381760120391849 475145280361175548 237572640180587774 118786320090293887 356358960270881662 178179480135440831 534538440406322494 267269220203161247 801807660609483742 400903830304741871 1202711490914225614 601355745457112807 1804067236371338422 902033618185669211 2706100854557007634 1353050427278503817 4059151281835511452 2029575640917755726 1014787820458877863 3044363461376633590 1522181730688316795 4566545192064950386 2283272596032475193 6849817788097425580 3424908894048712790 1712454447024356395 5137363341073069186 2568681670536534593 7706045011609603780 3853022505804801890 1926511252902400945 5779533758707202836 2889766879353601418 1444883439676800709 4334650319030402128 2167325159515201064 1083662579757600532 541831289878800266 270915644939400133 812746934818200400 406373467409100200 203186733704550100 101593366852275050 50796683426137525 152390050278412576 76195025139206288 38097512569603144 19048756284801572 9524378142400786 4762189071200393 14286567213601180 7143283606800590 3571641803400295 10714925410200886 5357462705100443 16072388115301330 8036194057650665 24108582172951996 12054291086475998 6027145543237999 18081436629713998 9040718314856999 27122154944570998 13561077472285499 40683232416856498 20341616208428249 61024848625284748 30512424312642374 15256212156321187 45768636468963562 22884318234481781 68652954703445344 34326477351722672 17163238675861336 8581619337930668 4290809668965334 2145404834482667 6436214503448002 3218107251724001 9654321755172004 4827160877586002 2413580438793001 7240741316379004 3620370658189502 1810185329094751 5430555987284254 2715277993642127 8145833980926382 4072916990463191 12218750971389574 6109375485694787 18328126457084362 9164063228542181 27492189685626544 13746094842813272 6873047421406636 3436523710703318 1718261855351659 5154785566054978 2577392783027489 7732178349082468 3866089174541234 1933044587270617 5799133761811852 2899566880905926 1449783440452963 4349350321358890 2174675160679445 6524025482038336 3262012741019168 1631006370509584 815503185254792 407751592627396 203875796313698 101937898156849 305813694470548 152906847235274 76453423617637 229360270852912 114680135426456 57340067713228 28670033856614 14335016928307 43005050784922 21502525392461 64507576177384 32253788088692 16126894044346 8063447022173 24190341066520 12095170533260 6047585266630 3023792633315 9071377899946 4535688949973 13607066849920 6803533424960 3401766712480 1700883356240 850441678120 425220839060 212610419530 106305209765 318915629296 159457814648 79728907324 39864453662 19932226831 59796680494 29898340247 89695020742 44847510371 134542531114 67271265557 201813796672 100906898336 50453449168 25226724584 12613362292 6306681146 3153340573 9460021720 4730010860 2365005430 1182502715 3547508146 1773754073 5321262220 2660631110 1330315555 3990946666 1995473333 5986420000 2993210000 1496605000 748302500 374151250 187075625 561226876 280613438 140306719 420920158 210460079 631380238 315690119 947070358 473535179 1420605538 710302769 2130908308 1065454154 532727077 1598181232 799090616 399545308 199772654 99886327 299658982 149829491 449488474 224744237 674232712 337116356 168558178 84279089 252837268 126418634 63209317 189627952 94813976 47406988 23703494 11851747 35555242 17777621 53332864 26666432 13333216 6666608 3333304 1666652 833326 416663 1249990 624995 1874986 937493 2812480 1406240 703120 351560 175780 87890 43945 131836 65918 32959 98878 49439 148318 74159 222478 111239 333718 166859 500578 250289 750868 375434 187717 563152 281576 140788 70394 35197 105592 52796 26398 13199 39598 19799 59398 29699 89098 44549 133648 66824 33412 16706 8353 25060 12530 6265 18796 9398 4699 14098 7049 21148 10574 5287 15862 7931 23794 11897 35692 17846 8923 26770 13385 40156 20078 10039 30118 15059 45178 22589 67768 33884 16942 8471 25414 12707 38122 19061 57184 28592 14296 7148 3574 1787 5362 2681 8044 4022 2011 6034 3017 9052 4526 2263 6790 3395 10186 5093 15280 7640 3820 1910 955 2866 1433 4300 2150 1075 3226 1613 4840 2420 1210 605 1816 908 454 227 682 341 1024 512 256 128 64 32 16 8 4 2 1
Antworten