Das deutsche Python-Forum

Seit 2002 Diskussionen rund um die Programmiersprache Python
https://www.python-forum.de/

Analytische Ableitung

https://www.python-forum.de/viewtopic.php?t=56249

Seite 1 von 1

Analytische Ableitung

Verfasst: Samstag 14. Januar 2023, 17:29
von Feedback1000
Hallo.
Im laufe einer Geradenschnitts muss ich das Varianzfortpflanzungsgesetzt anwenden. Dazu muss ich Ableitungen bilden und dann an einer bestimmten stelle ausrechnen.
Wie man Ableitungen bildet und die Formel f'(x) wird mir auch angezeigt - das hilft mir aber momentan nichts, da ich auch einen konkreten Wert ausrechnen.
Ich hoffe, dass dieses ziemlich praxisnahe Minibeispiel euch hilft das Ganze nachzuvollziehen:

Code: Alles auswählen

import numpy as np

points = [
    {'en': 'general', 'de': 'Allgemein'},
    {'name': '1097', 'x': 87883.671, 'y': 45384.496, 'z': None, 'sx': 0.005, 'sy': 0.005, 'sz': None, 'dnx': None,
     'dny': None, 'dnz': None},
    {'name': '13', 'x': 87833.852, 'y': 45388.750, 'z': None, 'sx': 0.005, 'sy': 0.005, 'sz': None, 'dnx': None,
     'dny': None, 'dnz': None},
    {'name': '4', 'x': 87839.347, 'y': 45408.780, 'z': None, 'sx': 0.005, 'sy': 0.005, 'sz': None, 'dnx': None,
     'dny': None, 'dnz': None},
    {'name': '3', 'x': 87877.157, 'y': 45376.062, 'z': None, 'sx': 0.005, 'sy': 0.005, 'sz': None, 'dnx': None,
     'dny': None, 'dnz': None}
]

# der Übersichtlichkeit halber speichere ich die Werte hier zwischen
x1 = points[1]['x']
y1 = points[1]['y']
sx1 = points[1]['sx']
sy1 = points[1]['sy']
x2 = points[2]['x']
y2 = points[2]['y']
sx2 = points[2]['sx']
sy2 = points[2]['sy']
x3 = points[3]['x']
y3 = points[3]['y']
sx3 = points[3]['sx']
sy3 = points[3]['sy']
x4 = points[4]['x']
y4 = points[4]['y']
sx4 = points[4]['sx']
sy4 = points[4]['sy']

# m1 = (y2-y1) / (x2-x1)
# m2 = (y4-y3) / (x4-x3)

# d{xs}/d{}
xs = (y3 - y1 + ((y2 - y1) / (x2 - x1)) * x1 - ((y4 - y3) / (x4 - x3)) * x3) / (
        ((y2 - y1) / (x2 - x1)) - ((y4 - y3) / (x4 - x3)))
# d{ys}/d{}
ys = y1 + ((y2 - y1) / (x2 - x1)) * (xs - x1)

# Hier müssen 8 Ableitungen gebildet und berechnet werden:
#
# d1{xs}/d1{x1} als d1xs_d1x1
# d1{ys}/d1{y1} als d1ys_d1y1
# d1{xs}/d1{x2} als d1xs_d1x2
# d1{ys}/d1{y2} als d1ys_d1y2
# d1{xs}/d1{x3} als d1xs_d1x3
# d1{ys}/d1{y3} als d1ys_d1y3
# d1{xs}/d1{x4} als d1xs_d1x4
# d1{ys}/d1{y4} als d1ys_d1y4
#

# Standardabweichung berechnen
s_s = np.sqrt(
    (d1xs_d1x1 ** 2) * (sx1 ** 2) +
    (d1ys_d1y1 ** 2) * (sy1 ** 2) +
    (d1xs_d1x2 ** 2) * (sx2 ** 2) +
    (d1ys_d1y2 ** 2) * (sy2 ** 2) +
    (d1xs_d1x3 ** 2) * (sx3 ** 2) +
    (d1ys_d1y3 ** 2) * (sy3 ** 2) +
    (d1xs_d1x4 ** 2) * (sx4 ** 2) +
    (d1ys_d1y4 ** 2) * (sy4 ** 2)
)
print(s_x)
Ich bin davon überzeugt, dass es mit Sicherheit für Berechnungen von Standartabweichungen etc. auch schon fertige Bibliotheken/Funktionen gibt, aber ich bin in der Lernphase (sowohl in Python, als auch in diesem Auswertetechnik-Seminar) und will alles "von Hand" rechnen.

Re: Analytische Ableitung

Verfasst: Samstag 14. Januar 2023, 18:09
von Feedback1000
Hier noch eine Korrektur, was die Mathematik angeht - die Grundfrage mit der Bildung der ersten Ableitung und Berechnung nach einer bestimmten Größe bleibt.

Code: Alles auswählen

import numpy as np

points = [
    {'en': 'general', 'de': 'Allgemein'},
    {'name': '1097', 'x': 87883.671, 'y': 45384.496, 'z': None, 'sx': 0.005, 'sy': 0.005, 'sz': None, 'dnx': None,
     'dny': None, 'dnz': None},
    {'name': '13', 'x': 87833.852, 'y': 45388.750, 'z': None, 'sx': 0.005, 'sy': 0.005, 'sz': None, 'dnx': None,
     'dny': None, 'dnz': None},
    {'name': '4', 'x': 87839.347, 'y': 45408.780, 'z': None, 'sx': 0.005, 'sy': 0.005, 'sz': None, 'dnx': None,
     'dny': None, 'dnz': None},
    {'name': '3', 'x': 87877.157, 'y': 45376.062, 'z': None, 'sx': 0.005, 'sy': 0.005, 'sz': None, 'dnx': None,
     'dny': None, 'dnz': None}
]

# der Übersichtlichkeit halber speichere ich die Werte hier zwischen
x1 = points[1]['x']
y1 = points[1]['y']
sx1 = points[1]['sx']
sy1 = points[1]['sy']
x2 = points[2]['x']
y2 = points[2]['y']
sx2 = points[2]['sx']
sy2 = points[2]['sy']
x3 = points[3]['x']
y3 = points[3]['y']
sx3 = points[3]['sx']
sy3 = points[3]['sy']
x4 = points[4]['x']
y4 = points[4]['y']
sx4 = points[4]['sx']
sy4 = points[4]['sy']

# m1 = (y2-y1) / (x2-x1)
# m2 = (y4-y3) / (x4-x3)

# d{xs}/d{}
xs = (y3 - y1 + ((y2 - y1) / (x2 - x1)) * x1 - ((y4 - y3) / (x4 - x3)) * x3) / (
        ((y2 - y1) / (x2 - x1)) - ((y4 - y3) / (x4 - x3)))
# d{ys}/d{}
ys = y1 + ((y2 - y1) / (x2 - x1)) * (xs - x1)

# Hier müssen 16 Ableitungen gebildet und berechnet werden:
#
# d1{xs}/d1{x1} als d1xs_d1x1
# d1{xs}/d1{y1} als d1xs_d1y1
# d1{xs}/d1{x2} als d1xs_d1x2
# d1{xs}/d1{y2} als d1xs_d1y2
# d1{xs}/d1{x3} als d1xs_d1x3
# d1{xs}/d1{y3} als d1xs_d1y3
# d1{xs}/d1{x4} als d1xs_d1x4
# d1{xs}/d1{y4} als d1xs_d1y4
#
# d1{ys}/d1{x1} als d1ys_d1x1
# d1{ys}/d1{y1} als d1ys_d1y1
# d1{ys}/d1{x2} als d1ys_d1x2
# d1{ys}/d1{y2} als d1ys_d1y2
# d1{ys}/d1{x3} als d1ys_d1x3
# d1{ys}/d1{y3} als d1ys_d1y3
# d1{ys}/d1{x4} als d1ys_d1x4
# d1{ys}/d1{y4} als d1ys_d1y4
#

# Standardabweichung berechnen
s_xs = np.sqrt(
    (d1xs_d1x1 ** 2) * (sx1 ** 2) +
    (d1xs_d1y1 ** 2) * (sy1 ** 2) +
    (d1xs_d1x2 ** 2) * (sx2 ** 2) +
    (d1xs_d1y2 ** 2) * (sy2 ** 2) +
    (d1xs_d1x3 ** 2) * (sx3 ** 2) +
    (d1xs_d1y3 ** 2) * (sy3 ** 2) +
    (d1xs_d1x4 ** 2) * (sx4 ** 2) +
    (d1xs_d1y4 ** 2) * (sy4 ** 2)
)
print(s_xs)

s_ys = np.sqrt(
    (d1ys_d1x1 ** 2) * (sx1 ** 2) +
    (d1ys_d1y1 ** 2) * (sy1 ** 2) +
    (d1ys_d1x2 ** 2) * (sx2 ** 2) +
    (d1ys_d1y2 ** 2) * (sy2 ** 2) +
    (d1ys_d1x3 ** 2) * (sx3 ** 2) +
    (d1ys_d1y3 ** 2) * (sy3 ** 2) +
    (d1ys_d1x4 ** 2) * (sx4 ** 2) +
    (d1ys_d1y4 ** 2) * (sy4 ** 2)
)
print(s_ys)

Re: Analytische Ableitung

Verfasst: Sonntag 15. Januar 2023, 22:58
von Feedback1000
So, mittlerweile bin ich zwar ein wenig weiter und es passieren Dinge, aber nun bin ich kurz vor dem Verzweifeln angekommen:
die finale Berechnung schein noch nicht durzulaufen, da augenscheinlich das Symbol f nicht berechnet wird und somit auch die folgenden Berechnungen scheitern.
Hat jemand einen Hinweis für mich, an welcher Schraube ich drehen muss?

Code: Alles auswählen

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

# In[37]:


import sympy as sp


# In[38]:


points = [
    {'en': 'general', 'de': 'Allgemein'},
    {'name': '1097', 'x': 87883.671, 'y': 45384.496, 'z': None, 'sx': 0.005, 'sy': 0.005, 'sz': None, 'dnx': 0.00001, 'dny': 0.00001, 'dnz': None},
    {'name': '13', 'x': 87833.852, 'y': 45388.750, 'z': None, 'sx': 0.005, 'sy': 0.005, 'sz': None, 'dnx': 0.00001, 'dny': 0.00001, 'dnz': None},
    {'name': '4', 'x': 87839.347, 'y': 45408.780, 'z': None, 'sx': 0.005, 'sy': 0.005, 'sz': None, 'dnx': 0.00001, 'dny': 0.00001, 'dnz': None},
    {'name': '3', 'x': 87877.157, 'y': 45376.062, 'z': None, 'sx': 0.005, 'sy': 0.005, 'sz': None, 'dnx': 0.00001, 'dny': 0.00001, 'dnz': None}
]


# In[40]:


x1, y1, x2, y2, x3, y3, x4, y4 = sp.symbols('a b c d e f g h')

m1 = (y2 - y1) / (x2 - x1)
m2 = (y4 - y3) / (x4 - x3)

# d{xs}/d{}
xs = (y3 - y1 + (m1) * x1 - (m2) * x3) / ((m1) - (m2))
# xs = (y3 - y1 + ((y2 - y1) / (x2 - x1)) * x1 - ((y4 - y3) / (x4 - x3)) * x3) / (((y2 - y1) / (x2 - x1)) - ((y4 - y3) / (x4 - x3)))
# d{ys}/d{}
ys = y1 + ((y2 - y1) / (x2 - x1)) * ((xs) - x1)
# ys = y1 + ((y2 - y1) / (x2 - x1)) * ((y3 - y1 + ((y2 - y1) / (x2 - x1)) * x1 - ((y4 - y3) / (x4 - x3)) * x3) / (((y2 - y1) / (x2 - x1)) - ((y4 - y3) / (x4 - x3))) - x1)

# print(xs.free_symbols)
# print(ys.free_symbols)


# In[41]:


d1xs_x1 = sp.diff(xs, x1)
d1xs_y1 = sp.diff(xs, y1)
d1xs_x2 = sp.diff(xs, x2)
d1xs_y2 = sp.diff(xs, y2)
d1xs_x3 = sp.diff(xs, x3)
d1xs_y3 = sp.diff(xs, y3)
d1xs_x4 = sp.diff(xs, x4)
d1xs_y4 = sp.diff(xs, y4)

d1ys_x1 = sp.diff(ys, x1)
d1ys_y1 = sp.diff(ys, y1)
d1ys_x2 = sp.diff(ys, x2)
d1ys_y2 = sp.diff(ys, y2)
d1ys_x3 = sp.diff(ys, x3)
d1ys_y3 = sp.diff(ys, y3)
d1ys_x4 = sp.diff(ys, x4)
d1ys_y4 = sp.diff(ys, y4)

# print(f'----- {d1xs_x1}')
# print(f'----- {d1xs_y1}')
# print(f'----- {d1xs_x2}')
# print(f'----- {d1xs_y2}')
# print(f'----- {d1xs_x3}')
# print(f'----- {d1xs_y3}')
# print(f'----- {d1xs_x4}')
# print(f'----- {d1xs_y4}')
# print(f'----- {d1ys_x1}')
# print(f'----- {d1ys_y1}')
# print(f'----- {d1ys_x2}')
# print(f'----- {d1ys_y2}')
# print(f'----- {d1ys_x3}')
# print(f'----- {d1ys_y3}')
# print(f'----- {d1ys_x4}')
# print(f'----- {d1ys_y4}')


# In[42]:


sub = {
    x1: points[1]['x'], 
    y1: points[1]['y'], 
    x2: points[2]['x'], 
    y2: points[2]['y'], 
    x3: points[3]['x'], 
    x3: points[3]['y'], 
    y4: points[4]['x'], 
    x4: points[4]['y']
}


# In[43]:


d1xs_x1 = xs.subs(sub)
d1xs_y1 = xs.subs(sub)
d1xs_x2 = xs.subs(sub)
d1xs_y2 = xs.subs(sub)
d1xs_x3 = xs.subs(sub)
d1xs_y3 = xs.subs(sub)
d1xs_x4 = xs.subs(sub)
d1xs_y4 = xs.subs(sub)

d1ys_x1 = ys.subs(sub)
d1ys_y1 = ys.subs(sub)
d1ys_x2 = ys.subs(sub)
d1ys_y2 = ys.subs(sub)
d1ys_x3 = ys.subs(sub)
d1ys_y3 = ys.subs(sub)
d1ys_x4 = ys.subs(sub)
d1ys_y4 = ys.subs(sub)

print(d1xs_x1)
print(d1xs_y1)
print(d1xs_x2)
print(d1xs_y2)
print(d1xs_x3)
print(d1xs_y3)
print(d1xs_x4)
print(d1xs_y4)
print(d1ys_x1)
print(d1ys_y1)
print(d1ys_x2)
print(d1ys_y2)
print(d1ys_x3)
print(d1ys_y3)
print(d1ys_x4)
print(d1ys_y4)


# In[44]:


# Standardabweichung berechnen
s_xs = sp.sqrt(
    (d1xs_x1 ** 2) * (points[1]['sx'] ** 2) +
    (d1xs_y1 ** 2) * (points[1]['sy'] ** 2) +
    (d1xs_x2 ** 2) * (points[2]['sx'] ** 2) +
    (d1xs_y2 ** 2) * (points[2]['sy'] ** 2) +
    (d1xs_x3 ** 2) * (points[3]['sx'] ** 2) +
    (d1xs_y3 ** 2) * (points[3]['sy'] ** 2) +
    (d1xs_x4 ** 2) * (points[4]['sx'] ** 2) +
    (d1xs_y4 ** 2) * (points[4]['sy'] ** 2)
)
print(f'S_xS = {s_xs}')

s_ys = sp.sqrt(
    (d1ys_x1 ** 2) * (points[1]['sx'] ** 2) +
    (d1ys_y1 ** 2) * (points[1]['sy'] ** 2) +
    (d1ys_x2 ** 2) * (points[2]['sx'] ** 2) +
    (d1ys_y2 ** 2) * (points[2]['sy'] ** 2) +
    (d1ys_x3 ** 2) * (points[3]['sx'] ** 2) +
    (d1ys_y3 ** 2) * (points[3]['sy'] ** 2) +
    (d1ys_x4 ** 2) * (points[4]['sx'] ** 2) +
    (d1ys_y4 ** 2) * (points[4]['sy'] ** 2)
)
print(f'S_yS = {s_ys}')

Re: Analytische Ableitung

Verfasst: Sonntag 15. Januar 2023, 23:11
von Dennis89
Hallo,

der Code läuft ohne Fehlermeldung durch. Kannst du dein Problem mal genauer erklären?
In 'sub' ist zwei mal ein 'x3', ist das so gewollt?
'd1xs_x1' und Co. definierst du und ohne was damit zu machen werden die Namen wieder überschrieben.
Vielleicht solltest du erst mal aufräumen und alles wegwerfen, was da nicht reingehört.

Grüße
Dennis

Re: Analytische Ableitung

Verfasst: Montag 16. Januar 2023, 07:54
von Feedback1000
Erst einmal vielen Dank für deinen Kommentar. Der Hinweis mit x3 in sub war das, was mich wahnsinnig gemacht hat.

Nun aber noch ein riesen mathematisches Problem (denn eine Standardabweichung von 1.2 km find ich dann doch etwas viel):
es werden immer alle Werte aus symbols() für die Ableitung als Parameter behandelt. Das will ich nicht. Ich brauche eine Möglichkeit, wie ich „reseten“ kann, sodass er quasi nur meine abzuleitende Größe nimmt.
Also dass symbols für
d1xs_x1 = sp.diff(xs, x1) nur x1 kennt, für
d1xs_y1 = sp.diff(xs, y1) nur y1 kennt,
etc.

Ja, aufräumen werde ich, sobald Ich weiß, dass die Mathematik in meinem Skript passt.

Re: Analytische Ableitung

Verfasst: Montag 16. Januar 2023, 08:48
von Sirius3
Eine Liste sollte nur gleichartige Elemente enthalten. Dein erstes Element in `points` weicht davon ab, sollte also nicht existieren.
Warum nennst Du die Symbole a, b, c, d, e, f x1, y1, x2, y2, x3, y3, das ist sehr verwirrend.
Es ist ja nicht nur, dass x3 doppelt vorkommt, sondern dass x4 und y4 auch falsch sind.

Wo ist das Problem mit den Symbolen, das ist ja der Sinn des symbolischen Rechnens. Bei der Bildung der Ableitung nach x1 ist nur x1 relevant. Alle weiteren Symbole werden ja nicht angefasst.
Und beim Berechnen der Standardabweichung solltest Du Dich dann entscheiden, ob Du Symbolisch oder Numerisch rechnen willst, gemischt ist wenig sinnvoll.

Code: Alles auswählen

import sympy as sp

x1, y1, x2, y2, x3, y3, x4, y4 = all_symbols = sp.symbols('x1 y1 x2 y2 x3 y3 x4 y4')

m1 = (y2 - y1) / (x2 - x1)
m2 = (y4 - y3) / (x4 - x3)
xs = (y3 - y1 + (m1) * x1 - (m2) * x3) / ((m1) - (m2))
ys = y1 + ((y2 - y1) / (x2 - x1)) * ((xs) - x1)

derivatives_xs = [sp.diff(xs, s) for s in all_symbols]
derivatives_ys = [sp.diff(ys, s) for s in all_symbols]


points = [
    {'name': '1097', 'x': 87883.671, 'y': 45384.496, 'z': None, 'sx': 0.005, 'sy': 0.005, 'sz': None, 'dnx': 0.00001, 'dny': 0.00001, 'dnz': None},
    {'name': '13', 'x': 87833.852, 'y': 45388.750, 'z': None, 'sx': 0.005, 'sy': 0.005, 'sz': None, 'dnx': 0.00001, 'dny': 0.00001, 'dnz': None},
    {'name': '4', 'x': 87839.347, 'y': 45408.780, 'z': None, 'sx': 0.005, 'sy': 0.005, 'sz': None, 'dnx': 0.00001, 'dny': 0.00001, 'dnz': None},
    {'name': '3', 'x': 87877.157, 'y': 45376.062, 'z': None, 'sx': 0.005, 'sy': 0.005, 'sz': None, 'dnx': 0.00001, 'dny': 0.00001, 'dnz': None}
]

sub = {
    x1: points[0]['x'], y1: points[0]['y'], 
    x2: points[1]['x'], y2: points[1]['y'], 
    x3: points[2]['x'], y3: points[2]['y'], 
    x4: points[3]['x'], y4: points[3]['y'],
}

deviations = [
    points[0]['sx'], points[0]['sy'],
    points[1]['sx'], points[1]['sy'],
    points[2]['sx'], points[2]['sy'],
    points[3]['sx'], points[3]['sy'],
]

standard_deviation_xs = sum(
    dxs.subs(sub) * ds for dxs, ds in zip(derivatives_xs, deviations)
) ** 0.5

standard_deviation_ys = sum(
    dys.subs(sub) * ds for dys, ds in zip(derivatives_ys, deviations)
) ** 0.5

Re: Analytische Ableitung

Verfasst: Montag 16. Januar 2023, 19:48
von Feedback1000
@Sirius3
Dein Code hilft super weiter - riesen Dank dafür. Das hin und her lag einfach daran, dass ich mit der Bibliothek noch am üben war/bin. Es soll erst einmal auf jeden Fall analytisch gerechnet werden - nummerisch kommt dann im nächsten Schritt (also zusätzlich auch noch - um die Mathematik zu üben).

Das Problem mit deinem aktuellen Code nur die berechnete Standardabweichung von >~7cm - die passt nicht so ganz zur Musterlösung von Sy ~4mm und Sx ~8mm.
Ne Idee, woran das liegen könnte?
... und nein, nicht an der Formel für xs und ys - die habe ich ca.700 mal kontrolliert. Man könnte diese Zeile sogar noch vereinfachen:

Code: Alles auswählen

ys = y1 + (m1) * ((xs) - x1)
(Die zusätzlichen Klammern bei xs und ys sind für meine Übersicht...)

Zur Info: In der Vermessung (wider der "klassischen Mathematik") ist y der Rechtwert und x ist der Hochwert. Sollte aber für deinen Code keinen Unterschied machen, oder?

Re: Analytische Ableitung

Verfasst: Montag 16. Januar 2023, 21:54
von Sirius3
Solche unnötigen Klammern tragen eher zur Unübersichtlichkeit bei.
Die Formeln sind ja recht einfach, so dass Du den Fehler sicher selber finden kannst.

Re: Analytische Ableitung

Verfasst: Dienstag 17. Januar 2023, 02:56
von Feedback1000
Danke!

Re: Analytische Ableitung

Verfasst: Donnerstag 19. Januar 2023, 00:58
von Feedback1000
@Sirius
nun bin ich soweit, dass das erste grobe Konzept steht.
Nun will ich, dass ein paar Spezialfälle beim Geradenschnitt abgefangen werden (momentan angefangen, dass eines der Geraden einen Anstieg von NULL hat - um Division durch Null auszuschließen).
Wo an welcher Stelle kann/sollte ich so etwas einbauen? Denn nach

Code: Alles auswählen

x1, y1, x2, y2, x3, y3, x4, y4 = all_symbols = sp.symbols('x1 y1 x2 y2 x3 y3 x4 y4')
ist das ja nicht mehr möglich, oder? Aber wenn ich das davor mache, dann müsste ich ja für alle Fälle danach auch noch einmal alles doppelt "abfangen", bzw. "Notfallpläne" einbauen.

Code: Alles auswählen

import sympy as sp
import numpy as np
import matplotlib.pyplot as plt

# ## Points


# general
p1 = [
    {'name': '1097', 'x': 87883.671, 'y': 45384.496, 'z': None, 'sx': 0.005, 'sy': 0.005, 'sz': None, 'dnx': 0.00001,
     'dny': 0.00001, 'dnz': None},
    {'name': '13', 'x': 87833.852, 'y': 45388.750, 'z': None, 'sx': 0.005, 'sy': 0.005, 'sz': None, 'dnx': 0.00001,
     'dny': 0.00001, 'dnz': None},
    {'name': '4', 'x': 87839.347, 'y': 45408.780, 'z': None, 'sx': 0.005, 'sy': 0.005, 'sz': None, 'dnx': 0.00001,
     'dny': 0.00001, 'dnz': None},
    {'name': '3', 'x': 87877.157, 'y': 45376.062, 'z': None, 'sx': 0.005, 'sy': 0.005, 'sz': None, 'dnx': 0.00001,
     'dny': 0.00001, 'dnz': None}
]

# parallel general
p2 = [
    {'name': '1', 'x': 193.500, 'y': 233.500, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '2', 'x': 20.500, 'y': 455.500, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '3', 'x': 205.500, 'y': 270.500, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '4', 'x': 32.500, 'y': 492.500, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None}
]

# line 1 parallel y-axis
p3 = [
    {'name': '1', 'x': 62.655, 'y': 581.080, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '2', 'x': 62.655, 'y': 1296.034, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '3', 'x': 280.366, 'y': 797.596, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '4', 'x': 11.051, 'y': 850.639, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None}
]

# line 1 parallel x-axis
p4 = [
    {'en': 'line 1 parallel x-axis', 'de': 'Parallele zur x-Achse'},
    {'name': '1', 'x': 1238.208, 'y': 3173.142, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '2', 'x': 78.743, 'y': 3173.142, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '3', 'x': 781.143, 'y': 2965.895, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '4', 'x': 516.763, 'y': 3409.516, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None}
]

# line 1 and line 2 orthogonal general
p5 = [
    {'name': '1', 'x': 830.4180, 'y': 3683.1586, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None,
     'dny': None, 'dnz': None},
    {'name': '2', 'x': 626.1359, 'y': 3374.6642, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None,
     'dny': None, 'dnz': None},
    {'name': '3', 'x': 875.4828, 'y': 3461.4174, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None,
     'dny': None, 'dnz': None},
    {'name': '4', 'x': 608.6768, 'y': 3638.0938, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None,
     'dny': None, 'dnz': None}
]

# line 1 and line 2 orthogonal parallel axis
p6 = [
    {'name': '1', 'x': 1290.000, 'y': 2940.000, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '2', 'x': 920.000, 'y': 2940.000, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '3', 'x': 1130.000, 'y': 2780.000, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '4', 'x': 1130.000, 'y': 3100.000, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None}
]

# glancing intersection
p7 = [
    {'name': '1', 'x': 1302.775, 'y': 2227.863, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '2', 'x': 905.775, 'y': 2416.439, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '3', 'x': 1344.637, 'y': 2342.931, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '4', 'x': 969.363, 'y': 2575.557, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None}
]

# short base line
p8 = [
    {'name': '1', 'x': 1302.775, 'y': 2227.863, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '2', 'x': 905.775, 'y': 2416.439, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '3', 'x': 1150.483, 'y': 2620.745, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '4', 'x': 1152.410, 'y': 2678.668, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None,
     'dnz': None}
]

# short base line - line1 line2 100gon
p9 = [
    {'name': '1', 'x': 200, 'y': 200, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None, 'dnz': None},
    {'name': '2', 'x': 500, 'y': 500, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None, 'dnz': None},
    {'name': '3', 'x': 500, 'y': 200, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None, 'dnz': None},
    {'name': '4', 'x': 481.1950, 'y': 218.8050, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None,
     'dnz': None}
]


# ## Setup


def set_deviation(**args):
    global points
    for point in points:
        # print(f'Alter Punkt: {point}')
        point.update(args)
        # print(f'Neuer Punkt: {point}\n')


points = p3
# p1...general
# p2...parallel general
# p3...line 1 parallel y-axis
# p4...line 1 parallel x-axis
# p5...line 1 and line 2 orthogonal general
# p6...line 1 and line 2 orthogonal parallel axis
# p7...glancing intersection
# p8...short base line general
# p9...short base line - line1 line2 100gon
#
# missing:
# negativ signs
# (partially) negativ sign

set_deviation(sx=0.005, sy=0.005, sz=0.000, dnx=0.00001, dny=0.00001, dnz=0.00001)
# set_deviation(sx=0, sy=0, sz=0, dnx=0, dny=0, dnz=0)

tolerance_m = 5 * (np.pi / 180)
# tolerance_m:
# not yet further implemented
#
tolerance_axis_parallel = 5 * (np.pi / 180)
# tolerance_axis_parallel:
# not yet further implemented
# a dependency on the straight lines would also be conceivable here
# f.e. ratio of (average length line 1 and line 2) and (distance line 1 and line 2)


# ## Calculation


x1, y1, x2, y2, x3, y3, x4, y4 = all_symbols = sp.symbols('x1 y1 x2 y2 x3 y3 x4 y4')

if points[0]['x'] == points[1]['x']:
    ys = points[0]['y']
    print('Fall A')
elif points[2]['x'] == points[3]['x']:
    ys = points[2]['y']
    print('Fall B')
else:
    print('nix mit parallel zur y-Achse...')
    m1 = (y2 - y1) / (x2 - x1)
    m2 = (y4 - y3) / (x4 - x3)
    xs = (y3 - y1 + (m1) * x1 - (m2) * x3) / ((m1) - (m2))
    ys = y1 + (m1) * ((xs) - x1)

# m1 = (y2 - y1) / (x2 - x1)
# m2 = (y4 - y3) / (x4 - x3)
# xs = (y3 - y1 + (m1) * x1 - (m2) * x3) / ((m1) - (m2))
# ys = y1 + (m1) * ((xs) - x1)

derivatives_xs = [sp.diff(xs, s) for s in all_symbols]
derivatives_ys = [sp.diff(ys, s) for s in all_symbols]

sub = {
    x1: points[0]['x'], y1: points[0]['y'],
    x2: points[1]['x'], y2: points[1]['y'],
    x3: points[2]['x'], y3: points[2]['y'],
    x4: points[3]['x'], y4: points[3]['y'],
}

deviations = [
    points[0]['sx'], points[0]['sy'],
    points[1]['sx'], points[1]['sy'],
    points[2]['sx'], points[2]['sy'],
    points[3]['sx'], points[3]['sy'],
]

standard_deviation_xs = sum(
    dxs.subs(sub) ** 2 * ds ** 2 for dxs, ds in zip(derivatives_xs, deviations)
) ** 0.5

standard_deviation_ys = sum(
    dys.subs(sub) ** 2 * ds ** 2 for dys, ds in zip(derivatives_ys, deviations)
) ** 0.5

print(f'yS = {ys.subs(sub)} \u00B1{standard_deviation_ys}')
print(f'xS = {xs.subs(sub)} \u00B1{standard_deviation_xs}')


# ## Drawing


def draw_labels(x, y, names):
    for x, y, name in zip(x, y, names):
        label = f"({name})"

        plt.annotate(
            label,  # text
            (x, y),  # label position
            textcoords="offset points",  # how to position the text
            xytext=(0, 10),  # distance from text to points (x,y)
            ha='left'  # horizontal alignment can be left, right or center
        )


def draw_sketch(draw_intersection=False):
    # setup points
    x_g1 = [points[0]['x'], points[1]['x']]
    y_g1 = [points[0]['y'], points[1]['y']]
    x_g2 = [points[2]['x'], points[3]['x']]
    y_g2 = [points[2]['y'], points[3]['y']]

    # plot the lines
    plt.plot(y_g1, x_g1)
    plt.plot(y_g2, x_g2)

    # plot the points
    plt.scatter(y_g1, x_g1)
    plt.scatter(y_g2, x_g2)

    # setup labels
    point_x = [point['x'] for point in points]
    point_y = [point['y'] for point in points]
    point_names = [point['name'] for point in points]

    if draw_intersection == True:
        plt.scatter(ys.subs(sub), xs.subs(sub))
        point_x.append(xs.subs(sub))
        point_y.append(ys.subs(sub))
        point_names.append('S')

    draw_labels(point_y, point_x, point_names)

    # setup axis
    plt.axis('equal')  # same scale in all axis
    plt.show()


draw_sketch(draw_intersection=True)

# further ideas:
# Error ellipses

Re: Analytische Ableitung

Verfasst: Donnerstag 19. Januar 2023, 17:33
von Sirius3
Vergiss bitte gleich wieder, dass es `global` gibt. Alles was eine Funktion braucht, muß sie über ihre Argumente bekommen.
Dieser viele globale Code sollte eh in Funktionen wandern. Dann muß man auch kein `points` auf eines der vielen p`s setzen, sondern kann eine Funktion einfach mit dem passenden Argument aufrufen.

Du rechnest analytisch, also kannst Du auch die Randfälle analytisch lösen.

Code: Alles auswählen

def set_deviation(points, **args):
    for point in points:
        # print(f'Alter Punkt: {point}')
        point.update(args)
        # print(f'Neuer Punkt: {point}\n')


def draw_labels(x, y, names):
    for x, y, name in zip(x, y, names):
        plt.annotate(
            f"({name})",  # text
            (x, y),  # label position
            textcoords="offset points",  # how to position the text
            xytext=(0, 10),  # distance from text to points (x,y)
            ha='left'  # horizontal alignment can be left, right or center
        )

def draw_sketch(points, xs, ys, draw_intersection=False):
    # setup points
    x_g1 = [points[0]['x'], points[1]['x']]
    y_g1 = [points[0]['y'], points[1]['y']]
    x_g2 = [points[2]['x'], points[3]['x']]
    y_g2 = [points[2]['y'], points[3]['y']]

    # plot the lines
    plt.plot(y_g1, x_g1)
    plt.plot(y_g2, x_g2)

    # plot the points
    plt.scatter(y_g1, x_g1)
    plt.scatter(y_g2, x_g2)

    # setup labels
    point_x = [point['x'] for point in points]
    point_y = [point['y'] for point in points]
    point_names = [point['name'] for point in points]

    if draw_intersection:
        plt.scatter(ys, xs)
        point_x.append(xs)
        point_y.append(ys)
        point_names.append('S')

    draw_labels(point_y, point_x, point_names)

    # setup axis
    plt.axis('equal')  # same scale in all axis
    plt.show()


def calculate(points):
    x1, y1, x2, y2, x3, y3, x4, y4 = all_symbols = sp.symbols('x1 y1 x2 y2 x3 y3 x4 y4')

    m1 = (y2 - y1) / (x2 - x1)
    m2 = (y4 - y3) / (x4 - x3)
    xs = (y3 - y1 + m1 * x1 - m2 * x3) / (m1 - m2)
    ys = y1 + m1 * (xs - x1)

    derivatives_xs = [sp.diff(xs, s) for s in all_symbols]
    derivatives_ys = [sp.diff(ys, s) for s in all_symbols]

    if points[0]['x'] == points[1]['x']:
        print('Fall A')
        xs = sp.limit(xs, x2, x1)
        ys = sp.limit(ys, x2, x1)
        derivatives_xs = [sp.limit(f, x2, x1) for f in derivatives_xs)]
        derivatives_ys = [sp.limit(f, x2, x1) for f in derivatives_ys)]
    elif points[2]['x'] == points[3]['x']:
        print('Fall B')
        xs = sp.limit(xs, x4, x3)
        ys = sp.limit(ys, x4, x3)
        derivatives_xs = [sp.limit(f, x4, x3) for f in derivatives_xs)]
        derivatives_ys = [sp.limit(f, x4, x3) for f in derivatives_ys)]

    set_deviation(points, sx=0.005, sy=0.005, sz=0.000, dnx=0.00001, dny=0.00001, dnz=0.00001)
    # set_deviation(points, sx=0, sy=0, sz=0, dnx=0, dny=0, dnz=0)

    sub = {
        x1: points[0]['x'], y1: points[0]['y'],
        x2: points[1]['x'], y2: points[1]['y'],
        x3: points[2]['x'], y3: points[2]['y'],
        x4: points[3]['x'], y4: points[3]['y'],
    }

    deviations = [
        points[0]['sx'], points[0]['sy'],
        points[1]['sx'], points[1]['sy'],
        points[2]['sx'], points[2]['sy'],
        points[3]['sx'], points[3]['sy'],
    ]

    xs_value = xs.subs(sub)
    ys_value = ys.subs(sub)

    standard_deviation_xs = sum(
        dxs.subs(sub) ** 2 * ds ** 2 for dxs, ds in zip(derivatives_xs, deviations)
    ) ** 0.5

    standard_deviation_ys = sum(
        dys.subs(sub) ** 2 * ds ** 2 for dys, ds in zip(derivatives_ys, deviations)
    ) ** 0.5

    print(f'yS = {ys_value} \u00B1{standard_deviation_ys}')
    print(f'xS = {xs_value} \u00B1{standard_deviation_xs}')

    draw_sketch(points, xs_value, ys_value, draw_intersection=True)


def main():
    calculate(p3)

if __name__ == "__main__":
    main()

Re: Analytische Ableitung

Verfasst: Donnerstag 19. Januar 2023, 20:40
von Feedback1000
@Sirius: Komischerweise berechnet PyCharm für p3 seeeeeehr lange - ich habe bisher hier noch kein Ergebnis bekommen, ob wohl der eigentliche Spezialfall p5 berechnet wird.
Mit Debugging kenne ich mich gleich ganz nicht aus, aber ich vermute, dass hier einfach die Grenzwertberechnung seeeeeehr lang dauert, oder?
p4 wirft sofort einen KeyError. Ne Idee, woran das liegt?

Code: Alles auswählen

import sympy as sp
import numpy as np
import matplotlib.pyplot as plt

# ## Points


# general
p1 = [
    {'name': '1097', 'x': 87883.671, 'y': 45384.496, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': 0, 'dny': 0, 'dnz': 0},
    {'name': '13', 'x': 87833.852, 'y': 45388.750, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': 0, 'dny': 0, 'dnz': 0},
    {'name': '4', 'x': 87839.347, 'y': 45408.780, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': 0, 'dny': 0, 'dnz': 0},
    {'name': '3', 'x': 87877.157, 'y': 45376.062, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': 0, 'dny': 0, 'dnz': 0}
]

# parallel general
p2 = [
    {'name': '1', 'x': 193.500, 'y': 233.500, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '2', 'x': 20.500, 'y': 455.500, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '3', 'x': 205.500, 'y': 270.500, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '4', 'x': 32.500, 'y': 492.500, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None}
]

# line 1 parallel y-axis
p3 = [
    {'name': '1', 'x': 62.655, 'y': 581.080, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '2', 'x': 62.655, 'y': 1296.034, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '3', 'x': 280.366, 'y': 797.596, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '4', 'x': 11.051, 'y': 850.639, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None}
]

# line 1 parallel x-axis
p4 = [
    {'en': 'line 1 parallel x-axis', 'de': 'Parallele zur x-Achse'},
    {'name': '1', 'x': 1238.208, 'y': 3173.142, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '2', 'x': 78.743, 'y': 3173.142, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '3', 'x': 781.143, 'y': 2965.895, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '4', 'x': 516.763, 'y': 3409.516, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None}
]

# line 1 and line 2 orthogonal general
p5 = [
    {'name': '1', 'x': 830.4180, 'y': 3683.1586, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None,
     'dny': None, 'dnz': None},
    {'name': '2', 'x': 626.1359, 'y': 3374.6642, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None,
     'dny': None, 'dnz': None},
    {'name': '3', 'x': 875.4828, 'y': 3461.4174, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None,
     'dny': None, 'dnz': None},
    {'name': '4', 'x': 608.6768, 'y': 3638.0938, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None,
     'dny': None, 'dnz': None}
]

# line 1 and line 2 orthogonal parallel axis
p6 = [
    {'name': '1', 'x': 2800, 'y': 2800, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '2', 'x': 3500, 'y': 2800, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '3', 'x': 3100, 'y': 2400, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '4', 'x': 3100, 'y': 3500, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None}
]

# glancing intersection
p7 = [
    {'name': '1', 'x': 1302.775, 'y': 2227.863, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '2', 'x': 905.775, 'y': 2416.439, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '3', 'x': 1344.637, 'y': 2342.931, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '4', 'x': 969.363, 'y': 2575.557, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None}
]

# short base line
p8 = [
    {'name': '1', 'x': 1302.775, 'y': 2227.863, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '2', 'x': 905.775, 'y': 2416.439, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '3', 'x': 1150.483, 'y': 2620.745, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '4', 'x': 1152.410, 'y': 2678.668, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None,
     'dnz': None}
]

# short base line - line1 line2 100gon
p9 = [
    {'name': '1', 'x': 200, 'y': 200, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None, 'dnz': None},
    {'name': '2', 'x': 500, 'y': 500, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None, 'dnz': None},
    {'name': '3', 'x': 500, 'y': 200, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None, 'dnz': None},
    {'name': '4', 'x': 481.1950, 'y': 218.8050, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None,
     'dnz': None}
]


def set_deviation(points, **args):
    for point in points:
        # print(f'Alter Punkt: {point}')
        point.update(args)
        # print(f'Neuer Punkt: {point}\n')


def draw_labels(x, y, names):
    for x, y, name in zip(x, y, names):
        plt.annotate(
            f"({name})",  # text
            (x, y),  # label position
            textcoords="offset points",  # how to position the text
            xytext=(0, 10),  # distance from text to points (x,y)
            ha='left'  # horizontal alignment can be left, right or center
        )


def draw_sketch(points, xs, ys, draw_intersection=False):
    # setup points
    x_g1 = [points[0]['x'], points[1]['x']]
    y_g1 = [points[0]['y'], points[1]['y']]
    x_g2 = [points[2]['x'], points[3]['x']]
    y_g2 = [points[2]['y'], points[3]['y']]

    # plot the lines
    plt.plot(y_g1, x_g1)
    plt.plot(y_g2, x_g2)

    # plot the points
    plt.scatter(y_g1, x_g1)
    plt.scatter(y_g2, x_g2)

    # setup labels
    point_x = [point['x'] for point in points]
    point_y = [point['y'] for point in points]
    point_names = [point['name'] for point in points]

    if draw_intersection:
        plt.scatter(ys, xs)
        point_x.append(xs)
        point_y.append(ys)
        point_names.append('S')

    draw_labels(point_y, point_x, point_names)

    # setup axis
    plt.axis('equal')  # same scale in all axis
    plt.show()


def calculate(points):
    x1, y1, x2, y2, x3, y3, x4, y4 = all_symbols = sp.symbols('x1 y1 x2 y2 x3 y3 x4 y4')

    m1 = (y2 - y1) / (x2 - x1)
    m2 = (y4 - y3) / (x4 - x3)
    xs = (y3 - y1 + m1 * x1 - m2 * x3) / (m1 - m2)
    ys = y1 + m1 * (xs - x1)

    derivatives_xs = [sp.diff(xs, s) for s in all_symbols]
    derivatives_ys = [sp.diff(ys, s) for s in all_symbols]

    if points[0]['x'] == points[1]['x']:
        print('Fall A')
        xs = sp.limit(xs, x2, x1)
        ys = sp.limit(ys, x2, x1)
        derivatives_xs = [sp.limit(f, x2, x1) for f in derivatives_xs]
        derivatives_ys = [sp.limit(f, x2, x1) for f in derivatives_ys]
    elif points[2]['x'] == points[3]['x']:
        print('Fall B')
        xs = sp.limit(xs, x4, x3)
        ys = sp.limit(ys, x4, x3)
        derivatives_xs = [sp.limit(f, x4, x3) for f in derivatives_xs]
        derivatives_ys = [sp.limit(f, x4, x3) for f in derivatives_ys]

    set_deviation(points, sx=0.005, sy=0.005, sz=0.000, dnx=0.00001, dny=0.00001, dnz=0)
    # set_deviation(points, sx=0, sy=0, sz=0, dnx=0, dny=0, dnz=0)

    sub = {
        x1: points[0]['x'], y1: points[0]['y'],
        x2: points[1]['x'], y2: points[1]['y'],
        x3: points[2]['x'], y3: points[2]['y'],
        x4: points[3]['x'], y4: points[3]['y'],
    }

    deviations = [
        points[0]['sx'], points[0]['sy'],
        points[1]['sx'], points[1]['sy'],
        points[2]['sx'], points[2]['sy'],
        points[3]['sx'], points[3]['sy'],
    ]

    xs_value = xs.subs(sub)
    ys_value = ys.subs(sub)

    standard_deviation_xs = sum(
        dxs.subs(sub) ** 2 * ds ** 2 for dxs, ds in zip(derivatives_xs, deviations)
    ) ** 0.5

    standard_deviation_ys = sum(
        dys.subs(sub) ** 2 * ds ** 2 for dys, ds in zip(derivatives_ys, deviations)
    ) ** 0.5

    print(f'yS = {ys_value} \u00B1{standard_deviation_ys}')
    print(f'xS = {xs_value} \u00B1{standard_deviation_xs}')

    draw_sketch(points, xs_value, ys_value, draw_intersection=True)


def main():
    calculate(p6)
    # p1...OK - general
    # p2...     parallel general
    # p3...     line 1 parallel y-axis
    # p4...     line 1 parallel x-axis
    # p5...OK - line 1 and line 2 orthogonal general
    # p6...OK, but - line 1 and line 2 orthogonal parallel axis
    # p7...OK - glancing intersection
    # p8...OK - short base line general
    # p9...OK - short base line - line1 line2 100gon
    #
    # missing:
    # negativ signs
    # (partially) negativ sign


if __name__ == "__main__":
    main()

Re: Analytische Ableitung

Verfasst: Donnerstag 19. Januar 2023, 21:23
von Sirius3
p3 dauert etwas länger, funktioniert aber. Und bei p4 kannst Du mal vergleichen, was da der Unterschied zu den anderen p`s ist.

Re: Analytische Ableitung

Verfasst: Donnerstag 19. Januar 2023, 22:54
von Feedback1000
Ok, meine idiotischen Fehler bei p4 habe ich gefunden.
p3 habe ich jetzt mal laufen lassen und auch nach 10 Minuten kein Ergebnis bekommen. Ist das normal?
p10 und p11 müssen sicher vorher abgefangen werden, da der Anstieg ja identisch ist und somit kein Schnittpunkt zu ermitteln ist.

Code: Alles auswählen

import sympy as sp
import numpy as np
import matplotlib.pyplot as plt
from pprint import pprint

# ## Points

# general
p1 = [
    {'name': '1097', 'x': 87883.671, 'y': 45384.496, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': 0, 'dny': 0, 'dnz': 0},
    {'name': '13', 'x': 87833.852, 'y': 45388.750, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': 0, 'dny': 0, 'dnz': 0},
    {'name': '4', 'x': 87839.347, 'y': 45408.780, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': 0, 'dny': 0, 'dnz': 0},
    {'name': '3', 'x': 87877.157, 'y': 45376.062, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': 0, 'dny': 0, 'dnz': 0}
]
# parallel general
p2 = [
    {'name': '1', 'x': 193.500, 'y': 233.500, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '2', 'x': 20.500, 'y': 455.500, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '3', 'x': 205.500, 'y': 270.500, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '4', 'x': 32.500, 'y': 492.500, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None}
]
# line 1 parallel y-axis
p3 = [
    {'name': '1', 'x': 62.655, 'y': 581.080, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '2', 'x': 62.655, 'y': 1296.034, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '3', 'x': 280.366, 'y': 797.596, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '4', 'x': 11.051, 'y': 850.639, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None}
]
# line 1 parallel x-axis
p4 = [
    {'name': '1', 'x': 1300, 'y': 3200, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '2', 'x': 80, 'y': 3200, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '3', 'x': 800, 'y': 2900, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '4', 'x': 500, 'y': 3400, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None}
]
# line 1 and line 2 orthogonal general
p5 = [
    {'name': '1', 'x': 830.4180, 'y': 3683.1586, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None,
     'dny': None, 'dnz': None},
    {'name': '2', 'x': 626.1359, 'y': 3374.6642, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None,
     'dny': None, 'dnz': None},
    {'name': '3', 'x': 875.4828, 'y': 3461.4174, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None,
     'dny': None, 'dnz': None},
    {'name': '4', 'x': 608.6768, 'y': 3638.0938, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None,
     'dny': None, 'dnz': None}
]
# line 1 and line 2 orthogonal parallel axis
p6 = [
    {'name': '1', 'x': 2800, 'y': 2800, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '2', 'x': 3500, 'y': 2800, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '3', 'x': 3100, 'y': 2400, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '4', 'x': 3100, 'y': 3500, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None}
]
# glancing intersection
p7 = [
    {'name': '1', 'x': 1302.775, 'y': 2227.863, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '2', 'x': 905.775, 'y': 2416.439, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '3', 'x': 1344.637, 'y': 2342.931, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '4', 'x': 969.363, 'y': 2575.557, 'z': None, 'sx': None, 'sy': None, 'sz': None, 'dnx': None, 'dny': None,
     'dnz': None}
]
# short base line
p8 = [
    {'name': '1', 'x': 1302.775, 'y': 2227.863, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '2', 'x': 905.775, 'y': 2416.439, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '3', 'x': 1150.483, 'y': 2620.745, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None,
     'dnz': None},
    {'name': '4', 'x': 1152.410, 'y': 2678.668, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None,
     'dnz': None}
]
# short base line - line1 line2 100gon
p9 = [
    {'name': '1', 'x': 200, 'y': 200, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None, 'dnz': None},
    {'name': '2', 'x': 500, 'y': 500, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None, 'dnz': None},
    {'name': '3', 'x': 500, 'y': 200, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None, 'dnz': None},
    {'name': '4', 'x': 481.1950, 'y': 218.8050, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None,
     'dnz': None}
]
# parallel and ortogonal y axis
p10 = [
    {'name': '1', 'x': 200, 'y': 500, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None, 'dnz': None},
    {'name': '2', 'x': 200, 'y': 200, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None, 'dnz': None},
    {'name': '3', 'x': 350, 'y': 350, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None, 'dnz': None},
    {'name': '4', 'x': 350, 'y': 800, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None, 'dnz': None}
]
# parallel and ortogonal x axis
p11 = [
    {'name': '1', 'x': 200, 'y': 200, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None, 'dnz': None},
    {'name': '2', 'x': 500, 'y': 200, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None, 'dnz': None},
    {'name': '3', 'x': 900, 'y': 300, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None, 'dnz': None},
    {'name': '4', 'x': 350, 'y': 300, 'z': 0, 'sx': 0, 'sy': 0, 'sz': 0, 'dnx': None, 'dny': None, 'dnz': None}
]


def set_deviation(points, **args):
    for point in points:
        # print(f'Old point: {point}')
        point.update(args)
        # print(f'New point: {point}\n')


def draw_labels(x, y, names):
    for x, y, name in zip(x, y, names):
        plt.annotate(
            f"{name}",  # text
            (x, y),  # label position
            textcoords="offset points",  # how to position the text
            xytext=(2, 5),  # distance from text to points (x,y)
            ha='left'  # horizontal alignment can be left, right or center
        )


def draw_sketch(points, xs, ys, draw_intersection=False):
    # setup points
    x_g1 = [points[0]['x'], points[1]['x']]
    y_g1 = [points[0]['y'], points[1]['y']]
    x_g2 = [points[2]['x'], points[3]['x']]
    y_g2 = [points[2]['y'], points[3]['y']]

    # plot the lines
    plt.plot(y_g1, x_g1)
    plt.plot(y_g2, x_g2)

    # plot the points
    plt.scatter(y_g1, x_g1)
    plt.scatter(y_g2, x_g2)

    # setup labels
    point_x = [point['x'] for point in points]
    point_y = [point['y'] for point in points]
    point_names = [point['name'] for point in points]

    if draw_intersection:
        plt.scatter(ys, xs)
        point_x.append(xs)
        point_y.append(ys)
        point_names.append('S')

    draw_labels(point_y, point_x, point_names)

    # setup axis
    plt.axis('equal')  # same scale in all axis
    plt.show()


def calculate(points):
    x1, y1, x2, y2, x3, y3, x4, y4 = all_symbols = sp.symbols('x1 y1 x2 y2 x3 y3 x4 y4')

    m1 = (y2 - y1) / (x2 - x1)
    m2 = (y4 - y3) / (x4 - x3)
    xs = (y3 - y1 + m1 * x1 - m2 * x3) / (m1 - m2)
    ys = y1 + m1 * (xs - x1)

    derivatives_xs = [sp.diff(xs, s) for s in all_symbols]
    derivatives_ys = [sp.diff(ys, s) for s in all_symbols]

    if points[0]['x'] == points[1]['x']:
        print('Fall A')
        xs = sp.limit(xs, x2, x1)
        ys = sp.limit(ys, x2, x1)
        derivatives_xs = [sp.limit(f, x2, x1) for f in derivatives_xs]
        derivatives_ys = [sp.limit(f, x2, x1) for f in derivatives_ys]
    elif points[2]['x'] == points[3]['x']:
        print('Fall B')
        xs = sp.limit(xs, x4, x3)
        ys = sp.limit(ys, x4, x3)
        derivatives_xs = [sp.limit(f, x4, x3) for f in derivatives_xs]
        derivatives_ys = [sp.limit(f, x4, x3) for f in derivatives_ys]

    set_deviation(points, sx=0.005, sy=0.005, sz=0.000, dnx=0.00001, dny=0.00001, dnz=0.00001)

    sub = {
        x1: points[0]['x'], y1: points[0]['y'],
        x2: points[1]['x'], y2: points[1]['y'],
        x3: points[2]['x'], y3: points[2]['y'],
        x4: points[3]['x'], y4: points[3]['y'],
    }

    deviations = [
        points[0]['sx'], points[0]['sy'],
        points[1]['sx'], points[1]['sy'],
        points[2]['sx'], points[2]['sy'],
        points[3]['sx'], points[3]['sy'],
    ]

    xs_value = xs.subs(sub)
    ys_value = ys.subs(sub)

    standard_deviation_xs = sum(
        dxs.subs(sub) ** 2 * ds ** 2 for dxs, ds in zip(derivatives_xs, deviations)
    ) ** 0.5

    standard_deviation_ys = sum(
        dys.subs(sub) ** 2 * ds ** 2 for dys, ds in zip(derivatives_ys, deviations)
    ) ** 0.5

    print(f'yS = {ys_value} \u00B1{standard_deviation_ys}')
    print(f'xS = {xs_value} \u00B1{standard_deviation_xs}')

    draw_sketch(points, xs_value, ys_value, draw_intersection=True)


def main():
    calculate(p11)
    # p1 ...OK - general
    # p2 ...no tolerance implemented yet - parallel general
    # p3 ...     line 1 parallel y-axis
    # p4 ...OK - line 1 parallel x-axis
    # p5 ...OK - line 1 and line 2 orthogonal general
    # p6 ...OK, but - line 1 and line 2 orthogonal parallel axis
    # p7 ...OK - glancing intersection
    # p8 ...OK - short base line general
    # p9 ...OK - short base line - line1 line2 100gon
    # p10...     parallel and ortogonal y axis
    # p11...     parallel and ortogonal x axis
    #
    # missing:
    # negativ signs
    # (partially) negativ sign


if __name__ == "__main__":
    main()

Re: Analytische Ableitung

Verfasst: Dienstag 14. März 2023, 18:54
von Feedback1000
Hallo @Sirius und alle anderen, die sich mit der Thematik auskennen.

Heute mal zum selben/ähnlichen Thema, aber ein wenig von hinten durch die Brust ins Auge:

Gegeben sind alpha und beta in mehreren Messzyklen. Gesucht ist die Standartabweichung vom Ergänzugswinkel gamma.

Berechnung von alpha und beta und deren Standartabweichungen ist kein Problem. Das Problem ist mein Algorithmus für gamma:
Hier muss das sogenannte (einfache) Varianfortpflanzugsgesetz zum Einsatz kommen um die Standartabweichung von zu Berechnen.

Also S_y = wurzel( (dy / dalpha)**2 * (S_alpha)**2 + (dy / dbeta)**2 * (S_beta)**2 )

dy / dalpha = -1
dy / dbeta = -1
So weit, so bekannt. Das bedeutet aber auch, dass S_alpha, bzw. S_beta trotzdem eine Rolle spielen.

Natürlich könnte ich das auch so hart im Code implementieren, aber u.U. ist gamma noch von weiteren Größen abhängig.

Hat jemand einen zarten Hinweis für mich, wie ich das am geschicktesten entweder
A) im Code erweitere (also z.B. sub und deviations), oder
B) meinen Code für simple_vfg_tupel anpassen muss?

Hier mein Code:

Code: Alles auswählen

import sympy as sp
import matplotlib.pyplot as plt
from pprint import pprint
import vfg
import calc

measured_data = {
    'alpha': [
        {'name': 'a1', 'value': 177.8953, 's': 0.0000},
        {'name': 'a2', 'value': 177.8970, 's': 0.0000},
        {'name': 'a3', 'value': 177.8990, 's': 0.0000},
        {'name': 'a4', 'value': 177.8949, 's': 0.0000},
        {'name': 'a5', 'value': 177.8910, 's': 0.0000},
    ],
    'beta': [
        {'name': 'b1', 'value': 96.5439, 's': 0.0000},
        {'name': 'b2', 'value': 96.5401, 's': 0.0000},
        {'name': 'b3', 'value': 96.5483, 's': 0.0000},
        {'name': 'b4', 'value': 96.5412, 's': 0.0000},
        {'name': 'b5', 'value': 96.5477, 's': 0.0000},
    ],
}


# pprint(measured_data, sort_dicts=False)


def calculate(measurements):
    a1, a2, a3, a4, a5, b1, b2, b3, b4, b5 = all_symbols = sp.symbols('α_1 α_2 α_3 α_4 α_5 β_1 β_2 β_3 β_4 β_5')
    # print(all_symbols)

    sub = {
        a1: measurements['alpha'][0]['value'] * sp.N(sp.pi) / 200,
        a2: measurements['alpha'][1]['value'] * sp.N(sp.pi) / 200,
        a3: measurements['alpha'][2]['value'] * sp.N(sp.pi) / 200,
        a4: measurements['alpha'][3]['value'] * sp.N(sp.pi) / 200,
        a5: measurements['alpha'][4]['value'] * sp.N(sp.pi) / 200,
        b1: measurements['beta'][0]['value'] * sp.N(sp.pi) / 200,
        b2: measurements['beta'][1]['value'] * sp.N(sp.pi) / 200,
        b3: measurements['beta'][2]['value'] * sp.N(sp.pi) / 200,
        b4: measurements['beta'][3]['value'] * sp.N(sp.pi) / 200,
        b5: measurements['beta'][4]['value'] * sp.N(sp.pi) / 200,
    }
    sub = {
        a1: measurements['alpha'][0]['value'],
        a2: measurements['alpha'][1]['value'],
        a3: measurements['alpha'][2]['value'],
        a4: measurements['alpha'][3]['value'],
        a5: measurements['alpha'][4]['value'],
        b1: measurements['beta'][0]['value'],
        b2: measurements['beta'][1]['value'],
        b3: measurements['beta'][2]['value'],
        b4: measurements['beta'][3]['value'],
        b5: measurements['beta'][4]['value'],
    }
    # print(len(sub), sub)

    deviations = [
        measurements['alpha'][0]['s'],
        measurements['alpha'][1]['s'],
        measurements['alpha'][2]['s'],
        measurements['alpha'][3]['s'],
        measurements['alpha'][4]['s'],
        measurements['beta'][0]['s'],
        measurements['beta'][1]['s'],
        measurements['beta'][2]['s'],
        measurements['beta'][3]['s'],
        measurements['beta'][4]['s'],
    ]
    # print(len(deviations), deviations)

    # Aufgabe 1 - empirische Mittelwerte
    print('Aufgabe 1')
    mittelwert_alpha = (a1 + a2 + a3 + a4 + a5) / 5
    mittelwert_beta = (b1 + b2 + b3 + b4 + b5) / 5
    print(f'x\u0302_alpha = {mittelwert_alpha.subs(sub)} gon')
    print(f'x\u0302_beta = {mittelwert_beta.subs(sub)} gon')
    print()

    # Aufgabe 2 - Residuen
    print('Aufgabe 2')
    v_a1 = mittelwert_alpha - a1
    v_a2 = mittelwert_alpha - a2
    v_a3 = mittelwert_alpha - a3
    v_a4 = mittelwert_alpha - a4
    v_a5 = mittelwert_alpha - a5
    v_b1 = mittelwert_beta - b1
    v_b2 = mittelwert_beta - b2
    v_b3 = mittelwert_beta - b3
    v_b4 = mittelwert_beta - b4
    v_b5 = mittelwert_beta - b5
    sum_v_alpha = v_a1 + v_a2 + v_a3 + v_a4 + v_a5
    sum_v_beta = v_b1 + v_b2 + v_b3 + v_b4 + v_b5
    print(f'[v]_alpha = {sum_v_alpha.subs(sub)} gon')
    print(f'[v]_beta = {sum_v_beta.subs(sub)} gon')
    print()

    vv_a1 = v_a1 ** 2
    vv_a2 = v_a2 ** 2
    vv_a3 = v_a3 ** 2
    vv_a4 = v_a4 ** 2
    vv_a5 = v_a5 ** 2
    vv_b1 = v_b1 ** 2
    vv_b2 = v_b2 ** 2
    vv_b3 = v_b3 ** 2
    vv_b4 = v_b4 ** 2
    vv_b5 = v_b5 ** 2
    sum_vv_alpha = vv_a1 + vv_a2 + vv_a3 + vv_a4 + vv_a5
    sum_vv_beta = vv_b1 + vv_b2 + vv_b3 + vv_b4 + vv_b5
    print(f'[vv]_α = {sum_vv_alpha.subs(sub)} gon')
    print(f'[vv]_β = {sum_vv_beta.subs(sub)} gon')
    print()

    # Aufgabe 3 - empir. Stansabw. u. Standabw. d. Mittel
    print('Aufgabe 3')
    s_alpha = sp.sqrt(sum_vv_alpha / (5 - 1))
    s_beta = sp.sqrt(sum_vv_beta / (5 - 1))
    print(f'S_α = {s_alpha.subs(sub)} gon')
    print(f'S_β = {s_beta.subs(sub)} gon')
    print()

    s_dach_alpha = s_alpha / sp.sqrt(5)
    s_dach_beta = s_beta / sp.sqrt(5)
    print(f'S_α\u0302 = {sp.N(s_dach_alpha.subs(sub))} gon')
    print(f'S_β\u0302 = {sp.N(s_dach_beta.subs(sub))} gon')

    print()

    # Aufgabe 4
    print('Aufgabe 4')
    gamma = 400 - mittelwert_alpha - mittelwert_beta
    print(gamma)
    print(gamma.subs(sub))
    print()

    vfg.simple_vfg_tupel([('γ', gamma)], all_symbols, sub, deviations)
    print()


def main():
    calculate(measured_data)


if __name__ == '__main__':
    main()
Und die Datei vfg.py

Code: Alles auswählen

import sympy as sp


def simple_vfg(all_symbols, xn, yn, sub, deviations):
    xn_value = xn.subs(sub)
    yn_value = yn.subs(sub)

    derivatives_xn = [sp.diff(xn, s) for s in all_symbols]
    derivatives_yn = [sp.diff(yn, s) for s in all_symbols]

    standard_deviation_xn = sum(
        dxs.subs(sub) ** 2 * ds ** 2 for dxs, ds in zip(derivatives_xn, deviations)
    ) ** 0.5
    standard_deviation_yn = sum(
        dys.subs(sub) ** 2 * ds ** 2 for dys, ds in zip(derivatives_yn, deviations)
    ) ** 0.5

    print(f'yN = {yn_value} \u00B1{standard_deviation_yn}')
    print(f'xN = {xn_value} \u00B1{standard_deviation_xn}')


def simple_vfg_tupel(items, all_symbols, sub, deviations):
    for item in items:
        value = item[1].subs(sub)

        derivatives = [sp.diff(item[1], s) for s in all_symbols]

        standard_deviation = sum(
            dxs.subs(sub) ** 2 * ds ** 2 for dxs, ds in zip(derivatives, deviations)
        ) ** 0.5

        print(f'{item[0]} = {value} \u00B1{standard_deviation}')
Alle Zeiten sind UTC+01:00
Seite 1 von 1

Powered by phpBB® Forum Software © phpBB Limited

Deutsche Übersetzung durch phpBB.de