def find_non_0_ohne(A):
prec = std.get_prec("int")
if type(A[0]) == list:
A = transp_ohne(A)
for row in A:
n = 0
for item in row:
if round(item, prec) != 0:
return n
n += 1
return False
elif isinstance(A[0], Number):
n = 0
for item in A:
if item != 0:
return n
n += 1
return False
else:
err_far = std.get_color("err")
raise cla.InputError(
colored(
f"Ich hab ehrlich keine Ahnung was falsch ist. Die Funktion sollte sowieso nicht benutzt werden und keine Ahnung. Hier noch das A:\n{A}",
err_far))
def lgs_probe(A_1, A_2, x, b, prec, nummer=2, color=None, print_=True):
prec_int = std.get_prec("int")
A_1_darst = std.format_prec(A_1[nummer], prec, mehrere=False)
A_2_darst = std.format_prec(A_2[nummer], prec, mehrere=False, absval=True)
x_darst = std.format_prec(x, prec, mehrere=False, klammer=True)
b_darst = std.format_prec(b[nummer], prec, mehrere=False)
nchk = std.negcheck(A_2[nummer])
out = [
f"Einsetzen in {std.roman(nummer + 1)}:\n",
f"{std.roman(nummer + 1)}. {A_1_darst} ∙ {x_darst[0]} {nchk[0]} {A_2_darst} ∙ {x_darst[1]} = {b_darst}"
]
A_1_darst = std.format_prec(A_1[nummer] * x[0], prec, mehrere=False)
A_2_darst = std.format_prec(A_2[nummer] * x[1],
prec,
mehrere=False,
absval=True)
b_darst = std.format_prec(b[nummer], prec, mehrere=False)
nchk = std.negcheck(A_2[nummer] * x[1])
out.append("\n")
out.append("Vereinfachen:\n")
out.append(
f"{std.roman(nummer + 1)}. {A_1_darst} {nchk[0]} {A_2_darst} = {b_darst}"
)
wert = A_1[nummer] * x[0] + A_2[nummer] * x[1]
wert_darst = std.format_prec(wert, prec)
if round(wert, prec_int) == round(b[nummer], prec_int):
zeichen = "="
else:
zeichen = "≠"
out.append("\n")
out.append("Zusammenfassen:\n")
out.append(
colored(f"{std.roman(nummer + 1)}. {wert_darst} {zeichen} {b_darst}",
color))
if print_:
for item in out:
print(item)
return out
def main():
config = std.load_config()
prec_1 = config["Nachkommastellen 1"]
prec_2 = config["Nachkommastellen 2"]
prec_3 = config["Nachkommastellen 3"]
prec_parser = config["Nachkommastellen Parser"]
prec_int = config["Nachkommastellen Intern"]
zwi_far, zwi_zwi_far, end_far, abs_far, men_far, err_far, ein_far = std.get_color(
value=False)
err = cla.Input()
while err.error:
cprint(
"Willkommen bei dem Analytischen Geometrie-Rechner von Mattis Seebeck.\n",
men_far.en)
cprint("Welche Funktionalität möchtest du benutzen?", men_far.en)
cprint("Zur Auswahl steht:\n", men_far.en)
cprint("0: Standardeinsetellungen ändern", men_far.en)
cprint("1: Standard Operationen ohne Rechenweg", men_far.en)
cprint("2: Standard Operationen mit Rechenweg", men_far.en)
cprint("3: Lineare Algebra ohne Rechenweg", men_far.en)
cprint("4: Lineare Algebra mit Rechenweg", men_far.en)
func = std.user_input(err, max_amount=4, min_amount=0)
err.error = True
darst = None
if func == 0:
while True:
err.error = True
while err.error:
cprint("Veränderbare Einstellungen:\n", men_far.en)
cprint("0: Standards wiederherstellen", men_far.en)
cprint("1: Farben verändern", men_far.en)
cprint("2: Anzahl der Nachkommastellen verändern", men_far.en)
cprint("3: Variablen verändern", men_far.en)
cprint("4: Diverses", men_far.en)
cprint("5: Rechen- und Lösungswege", men_far.en)
einst = std.user_input(err, max_amount=5, min_amount=0)
err.error = True
standards = False
if einst == 0:
standards = True
std.save_config_standard()
elif einst == 1:
while err.error:
for i, (color, item) in enumerate(zip(
std.get_color(value=False),
std.format_prec(
std.get_iter("config_farben_darst"),
string=True,
ausrichtung="links",
dotted=True,
dotted_len=2)),
start=1):
cprint(f"{i}: {item}", men_far.en, end="")
cprint(color.de, color.en)
print()
einst = std.user_input(err, max_amount=7)
err.error = True
while err.error:
cprint("Welche Farbe möchtest du wählen?\n")
std.display_farben()
far, darst = std.user_input(err, string=True, farben=True)
neu_far = cla.Farbe(far, darst)
for i, item in enumerate(std.get_iter("config_farben"),
start=1):
if einst == i:
std.save_config(item, neu_far.de)
break
elif einst == 2:
while err.error:
for i, (prec, item) in enumerate(zip(
std.get_prec(),
std.format_prec(std.get_iter("config_prec_darst"),
string=True,
ausrichtung="links",
dotted=True,
dotted_len=4)),
start=1):
cprint(f"{i}: {item}{prec}", men_far.en)
print()
einst = std.user_input(err, max_amount=5)
err.error = True
while err.error:
if einst == 5:
cprint(
"Mit wie vielen Nachkommastellen soll gerechnet werden?",
men_far.en)
else:
cprint(
"Wie viele Nachkommastellen sollen angezeigt werden? Maximal 15",
men_far.en)
prec = std.user_input(err, max_amount=15)
for i, item in enumerate(std.get_iter("config_prec")):
if einst == i:
std.save_config(item, prec)
break
elif einst == 3:
while err.error:
for i, (conf, item) in enumerate(zip(
std.get_iter("config_buchst"),
std.format_prec(
std.get_iter("config_buchst_darst"),
string=True,
ausrichtung="links",
dotted=True,
dotted_len=4)),
start=1):
pass
for i, (conf, item) in enumerate(zip(
std.get_iter("config_buchst"),
std.format_prec(
std.get_iter("config_buchst_darst"),
string=True,
ausrichtung="links",
dotted=True,
dotted_len=4)),
start=1):
if isinstance(config[conf], list):
cprint(f" {' ' * len(item)}{config[conf][0]}",
men_far.en)
cprint(f"{i:<2}: {item}{config[conf][1]}",
men_far.en)
print()
else:
cprint(f"{i:<2}: {item}{config[conf]}", men_far.en)
print()
einst = std.user_input(err, max_amount=19)
err.error = True
pfeil = False
while err.error:
cprint(
'Tipp: Wenn du "pfeil" in die Eingabe schreibst, wird der Buchstabe mit pfeil angezeigt\n',
men_far.en)
cprint("Was für ein Buchstabe soll zugewiesen werden?")
buchst = std.user_input(err, string=True)
if buchst == "pfeil":
pfeil = True
err.error = True
buchst = std.format_prec(buchst,
ausrichtung="links",
string=True,
pfeil=pfeil)
for i, item in enumerate(std.get_iter("config_buchst"),
start=1):
if einst == i:
std.save_config(item, buchst)
break
elif einst == 4:
while err.error:
for i, (conf, item) in enumerate(zip(
std.get_iter("config_divers"),
std.format_prec(
std.get_iter("config_divers_darst"),
string=True,
ausrichtung="links",
dotted=True,
dotted_len=4)),
start=1):
if isinstance(config[conf], bool):
if config[conf]:
conf = "Ja"
else:
conf = "Nein"
else:
conf = config[conf]
cprint(f"{i}: {item}{conf}", men_far.en)
print()
einst = std.user_input(err, max_amount=i)
err.error = True
while err.error:
cprint("Ja oder Nein?", men_far.en)
wert = std.user_input(err, string=True, ja=True, nein=True)
if einst == 1:
std.save_config("Bruch", wert)
elif einst == 2:
std.save_config("Komma", wert)
elif einst == 3:
std.save_config("Gauss Pretty", wert)
elif einst == 4:
std.save_config("Gauss Fast", wert)
elif einst == 5:
while err.error:
for i, (conf, item) in enumerate(zip(
std.get_iter("config_lösung"),
std.format_prec(
std.get_iter("config_lösung_darst"),
string=True,
ausrichtung="links",
dotted=True,
dotted_len=4)),
start=1):
if isinstance(config[conf], bool):
if config[conf]:
conf = "Ja"
else:
conf = "Nein"
else:
conf = config[conf]
cprint(f"{f' {i}' if i < 10 else i}: {item}{conf}",
men_far.en)
print()
einst = std.user_input(err, max_amount=i)
err.error = True
if 1 <= einst <= 10:
while err.error:
cprint(
f"Soll ein {std.get_iter('config_lösung_darst')[einst - 1]} angezeigt werden?",
men_far.en)
wert = std.user_input(err,
ja=True,
nein=True,
string=True)
elif 11 <= einst <= 13:
while err.error:
cprint(
f"Welcher {std.get_iter('config_lösung_darst')[einst - 1]} soll gewählt werden?\n",
men_far.en)
cprint("1: Lineares Gleichungsystem", men_far.en)
cprint("2: Einsetzen in die Koordinatenform",
men_far.en)
if einst > 11:
cprint("3: Passend")
wert = std.user_input(
err,
max_amount=3 if einst > 11 else 2,
erlaubte_werte=["lgs", "koor", "passend"])
if wert == 1:
wert = "lgs"
elif wert == 2:
wert = "koor"
elif wert == 3:
wert = "passend"
elif 14 <= einst <= 19:
lsg = []
if einst in [14, 16]:
lsg = ["hilf", "geo"]
else:
lsg = ["hnf", "lfp"]
while err.error:
cprint(
f"Welcher {std.get_iter('config_lösung_darst')[einst - 1]} soll gewählt werden?\n",
men_far.en)
for i, item in enumerate(lsg, start=1):
if item == "lfp":
cprint(f"{i}: Lotfußpunkt", men_far.en)
elif item == "hnf":
cprint(f"{i}: Hessesche Normalenform",
men_far.en)
elif item == "hilf":
cprint(f"{i}: Hilfsebene", men_far.en)
elif item == "geo":
cprint(f"{i}: Geometrischer Ansatz",
men_far.en)
wert = std.user_input(err,
max_amount=i,
erlaubte_werte=lsg)
wert = lsg[wert - 1]
for i, item in enumerate(std.get_iter("config_lösung"),
start=1):
if einst == i:
std.save_config(item, wert)
break
config = std.load_config()
prec_1 = config["Nachkommastellen 1"]
prec_2 = config["Nachkommastellen 2"]
prec_3 = config["Nachkommastellen 3"]
prec_parser = config["Nachkommastellen Parser"]
prec_int = config["Nachkommastellen Intern"]
zwi_far, zwi_zwi_far, end_far, abs_far, men_far, err_far, ein_far = std.get_color(
value=False)
std.cls()
if standards:
cprint("Standards erfolgreich wiederhergestellt!", men_far.en)
else:
cprint("Einstellung erfolgreich verändert!", men_far.en)
cprint("\nMöchtest du noch etwas verändern?", men_far.en)
err.error = True
back = std.user_input(err,
string=True,
ja=True,
nein=True,
random=True,
erlaubte_werte="")
if back == "r":
if random.randint(0, 1):
return
elif not back:
return
elif func in [1, 2]:
if func == 1:
rweg = "Ohne"
rechenweg = False
else:
rweg = "Mit"
rechenweg = "force"
while err.error:
cprint(
f"Welche Operation möchtest du benutzen ({rweg} Rechenweg)?\n",
men_far.en)
cprint("1: Vektor aus zwei Punkten berechnen", men_far.en)
cprint("2: Gerade aus zwei Punkten berechnen", men_far.en)
cprint("3: Ebene aus drei Punkten berechnen", men_far.en)
cprint("4: Betrag eines Vektors berechnen", men_far.en)
cprint("5: Normalenvektor berechnen", men_far.en)
cprint("6: Normaleneinheitsvektor berechnen", men_far.en)
cprint("7: Skalarprodukt berechnen", men_far.en)
cprint("8: Lineare Abhängigkeit testen", men_far.en)
cprint("9: Punktprobe von Punkt und Gerade", men_far.en)
cprint("10: Punktprobe von Punkt Ebene", men_far.en)
cprint("11: Schnittpunkt zweier Geraden berechnen", men_far.en)
cprint("12: Schnittpunkt von Gerade und Ebene berechnen",
men_far.en)
cprint("13: Schnittgerade zweier Ebenen berechnen", men_far.en)
cprint("14: Schnittwinkel zweier Geraden berechnen", men_far.en)
cprint("15: Schnittwinkel von Gerade und Ebene berechnen",
men_far.en)
cprint("16: Schnittwinkel zweier Ebenen berechnen", men_far.en)
cprint("17: Umrechnung zwischen Ebenengleichungen", men_far.en)
cprint("18: Sind die eingegebenen Ebenen gleich?", men_far.en)
cprint("19: Abstand zwischen Punkt und Gerade berechnen",
men_far.en)
cprint("20: Abstand zwischen zwei Geraden berechnen", men_far.en)
cprint("21: Abstand zwischen Punkt und Ebene berechnen",
men_far.en)
cprint("22: Abstand zwischen Gerade und Ebene berechnen",
men_far.en)
cprint("23: Abstand zwischen Ebene und Ebene berechnen",
men_far.en)
operation = std.user_input(err, max_amount=23)
if operation in [1, 2]:
P = std.parser("punkt")
Q = std.parser("punkt", buchst="Q", weitere=P)
parsed = [P, Q]
elif operation == 3:
P = std.parser("punkt")
Q = std.parser("punkt", buchst="Q", weitere=P)
T = std.parser("punkt", buchst="T", weitere=(P, Q))
parsed = [P, Q, T]
elif operation == 4:
parsed = [std.parser("vektor")]
elif operation in [5, 6, 7]:
u = std.parser("vektor", buchst="u")
v = std.parser("vektor", weitere=u)
parsed = [u, v]
elif operation == 8:
parsed = std.parser("linear abhängig")
elif operation in [9, 19]:
P = std.parser("punkt")
g = std.parser("gerade", weitere=P)
parsed = [P, g]
elif operation in [10, 21]:
darst = std.input_darst_ebene()
P = std.parser("punkt")
E = std.parser("ebene", darst=darst, weitere=P)
parsed = [P, E]
elif operation in [11, 14, 20]:
g = std.parser("gerade")
h = std.parser("gerade", buchst="h", weitere=g, param="s")
parsed = [g, h]
elif operation in [12, 15, 22]:
darst = std.input_darst_ebene()
g = std.parser("gerade")
E = std.parser("ebene", darst=darst, weitere=g)
parsed = [g, E]
elif operation in [13, 16, 18, 23]:
darst = std.input_darst_ebene(erste=True, zweite=True)
E = std.parser("ebene", darst=darst[0])
F = std.parser("ebene",
darst=darst[1],
buchst="F",
weitere=E,
param=["u", "v"])
parsed = [E, F]
elif operation == 17:
darst = std.input_umrechnen(von=True, nach=True)
E = std.parser("ebene", darst=darst[0])
parsed = [E]
stdop.standardoperationen(parsed, operation, rechenweg, darst)
elif func in [3, 4]:
if func == 3:
Rweg = "Ohne"
rechenweg = False
else:
Rweg = "Mit"
rechenweg = "force"
while err.error:
cprint(
f"Welche Operation möchtest du benutzen ({Rweg} Rechenweg)?\n",
men_far.en)
for i, item in enumerate(std.get_iter("operation_lagl_darst"),
start=1):
cprint(f"{i}: {item}", men_far.en)
operation = std.user_input(err, max_amount=i)
A, B = None, None
if operation == 1:
darst = std.input_nxm_mat(num="erste"), std.input_nxm_mat(
num="zweite")
A = std.parser("matrix", darst[0], True)
std.cls()
B = std.parser("matrix", darst[1], True, buchst="B", weitere=A)
elif operation == 2:
darst = std.input_nxm_mat()
cprint(f"Die Matrix hat eine {darst[0]} × {darst[1]} Dimension",
men_far.en)
A = std.parser("matrix", darst, True, param=True)
s = time.time()
stdop.standardoperationen_lagl([A, B], operation, rechenweg, darst)
return True
def schnittwinkel_formel(inp_1,
inp_2,
typ=None,
print_=True,
ausrechnen=False,
umstellen=False,
winkel="α",
color=None):
buchst = [None, None]
if typ is None:
typ = [None, None]
if ausrechnen is True:
ausrechnen = "F"
# Buchstaben Parsen
if isinstance(inp_1, cla.Gerade):
buchst[0] = inp_1.param
typ[0] = "gerade"
elif isinstance(inp_1, cla.Ebene):
if typ[1] == "ebene" or isinstance(inp_2, cla.Ebene):
buchst[0] = "n₁"
else:
buchst[0] = "n"
else:
if typ[0] == "gerade":
buchst[0] = "r"
elif typ[0] == "ebene":
if typ[1] == "ebene" or isinstance(inp_2, cla.Ebene):
buchst[0] = "n₁"
else:
buchst[0] = "n"
if isinstance(inp_2, cla.Gerade):
buchst[1] = inp_2.param
typ[1] = "gerade"
elif isinstance(inp_2, cla.Ebene):
if typ[0] == "ebene":
buchst[1] = "n₂"
else:
buchst[1] = "n"
else:
if typ[1] == "gerade":
buchst[1] = "r"
elif typ[1] == "ebene":
if typ[0] == "ebene":
buchst[1] = "n₁"
else:
buchst[1] = "n"
if ausrechnen:
prec, prec_2 = std.get_prec([1, 2])
if typ[0] == "gerade":
v1 = inp_1.rv.copy()
inp_1_darst = inp_1.display(prec=prec, nur="rv", print_=False)
else:
v1 = inp_1.nv.copy()
inp_1_darst = inp_1.display(prec=prec,
nur="nv",
darst="norm",
print_=False)
if typ[1] == "gerade":
v2 = inp_2.rv.copy()
inp_2_darst = inp_2.display(prec=prec, nur="rv", print_=False)
else:
v2 = inp_2.nv.copy()
inp_2_darst = inp_2.display(prec=prec,
nur="nv",
darst="norm",
print_=False)
if "bruch" in ausrechnen:
bruch_darst = std.format_prec(abs(ber.skalarprodukt(v1, v2)) /
(ber.absvec(v1) * ber.absvec(v2)),
prec_2,
liste=True)
else:
if "oben" in ausrechnen:
forma_list = [f"|{ber.skalarprodukt(v1, v2)}|"]
if "unten" not in ausrechnen:
forma_list.insert(0, "")
bruch_oben = std.format_prec(forma_list, prec, liste=True)
else:
bruch_oben = []
offen_kringel = [
"∘" if i == int(inp_1.dim / 2) else " "
for i in range(inp_1.dim)
]
for i in range(inp_1.dim):
bruch_oben.append(
f"┃ {inp_1_darst[i]} {offen_kringel[i]} {inp_2_darst[i]} ┃"
)
if "unten" in ausrechnen:
forma_list = [ber.absvec(v1) * ber.absvec(v2)]
if "oben" not in ausrechnen:
forma_list.append("")
forma_list.append("")
bruch_unten = std.format_prec(forma_list, prec, liste=True)
else:
bruch_unten = []
zu_kringel = [
"∙" if i == int(inp_1.dim / 2) else " "
for i in range(inp_1.dim)
]
for i in range(inp_1.dim):
bruch_unten.append(
f"┃{inp_1_darst[i]}┃ {zu_kringel[i]} ┃{inp_2_darst[i]}┃"
)
bruch_darst = std.format_prec(bruch_oben + bruch_unten,
bruch=True,
mehrere=False,
string=True,
ausrichtung="mitte")
else:
pfeile = [std.get_pfeil(len(_)) for _ in buchst]
bruch = [
f" {pfeile[0]} {pfeile[1]}", f"|{buchst[0]} ∘ {buchst[1]}|",
f" {pfeile[0]} {pfeile[1]}", f"|{buchst[0]}| ∙ |{buchst[1]}|"
]
bruch_darst = std.format_prec(bruch,
bruch=True,
mehrere=False,
string=True,
ausrichtung="mitte")
formel = "sin" if typ.count("gerade") == 1 and typ.count(
"ebene") == 1 else "cos"
formel_darst = []
mitte = int(len(bruch_darst) / 2)
for i in range(len(bruch_darst)):
if umstellen:
st = f"{winkel} = {formel}⁻¹ "
if i == mitte:
formel_darst.append(st)
else:
formel_darst.append(f" " * len(st))
else:
st = f"{formel}({winkel}) = "
if i == mitte:
formel_darst.append(st)
else:
formel_darst.append(" " * len(st))
out = []
if umstellen:
klam = std.get_klam(inp_1.dim if "bruch" not in ausrechnen else 1)
for fo, kl0, da, kl1 in zip(formel_darst, klam[0], bruch_darst,
klam[1]):
out.append(fo + kl0 + da + kl1)
else:
for a, b in zip(formel_darst, bruch_darst):
out.append(a + b)
if print_:
for _ in out:
cprint(_, color)
return out
def lgs_lösung(inp,
prec,
zeilen=True,
color=None,
param_list=None,
print_=True):
if isinstance(inp, (list, tuple)):
if inp[0] == "eind":
spez_lsg = True
inp = inp[1:]
elif inp[0] == "unend":
if any(row[0] == "spez" for row in inp[1]):
spez_lsg = True
else:
spez_lsg = False
if any(isinstance(row[0], str) for row in inp[1]):
param_list = []
for row in inp[1]:
if isinstance(row[0], str) and row[0] != "spez":
param_list.append(row[0])
inp = [item[1:] for item in inp[1]]
elif inp[0] == "keine":
cprint("L = ∅", color)
return
if not isinstance(inp[0], (list, tuple)):
inp = [inp]
if zeilen is True:
inp = transp_ohne(inp)
# inp wird in Spaltenform bearbeitet
prec_1, prec_int = std.get_prec([1, "int"])
dim_n = len(inp[0]) # dim_n = Anzahl der Zeilen
dim_m = len(inp) # dim_m = Anzahl der Spalten
mitte = int(dim_n / 2)
prec = std.prec_auffüllen(prec, dim_m)
if param_list is None:
param_list = []
for i in range(1, dim_m):
param_list.append(f" {std.übersetzung_zahl_param(i)}")
else:
for i, item in enumerate(param_list):
if item == "":
continue
if item[0] != " ":
param_list[i] = f" {item}"
if len(param_list) + 1 < dim_m:
i = len(param_list) + 1
while i < dim_m:
param_list.append(f" {std.übersetzung_zahl_param(i)}")
i += 1
if spez_lsg:
param_list.append("")
klam_r, klam_g = std.get_klam(dim_n, "r"), std.get_klam(dim_n, "g")
inp_darst = [std.format_prec(inp[i], prec_1) for i in range(dim_m)]
# Strings für Darstellung:
L_str = std.format_prec(
["L = " if i == mitte else "" for i in range(dim_n)],
prec_1,
string=True)
param_list_str_1 = [
std.format_prec([
f"{param_list[i]} ∙ " if j == mitte else "" for j in range(dim_n)
],
prec_1,
string=True) for i in range(len(param_list))
]
param_str = ""
for i, item in enumerate(param_list):
if i == 0:
param_str = item.strip()
elif item:
param_str += f", {item.strip()}"
if param_list:
param_str += f" ∈ ℝ"
param_list_str_2 = std.format_prec(
[param_str if _ == mitte else "" for _ in range(dim_n)], string=True)
plus_str = std.format_prec(
[f" +" if j == mitte else "" for j in range(dim_n)], string=True)
strich = [" │ " for i in range(dim_n)]
out = []
if spez_lsg:
anfang = 1
else:
anfang = 0
for i in range(dim_n):
out.append(f"{L_str[i]}{klam_g[0][i]}")
if spez_lsg:
out[i] += f" {klam_r[0][i]}{inp_darst[0][i]}{klam_r[1][i]}"
for j in range(anfang, dim_m):
out[i] += f"{plus_str[i] if spez_lsg or j != anfang else ''}{param_list_str_1[j - 1 if spez_lsg else j][i]}{klam_r[0][i]}{inp_darst[j][i]}{klam_r[1][i]}"
if any(param_list):
out[i] += f"{strich[i]}{param_list_str_2[i]}"
out[i] += f" {klam_g[1][i]}"
if print_:
for item in out:
cprint(item, color)
return out
def gauss_overset(zeile_1,
zeile_2,
operation,
div=None,
bruch_zahl_1=None,
bruch_zahl_2=None):
"""Gibt den Pfeil vor dem Gauss Algorithmus wieder"""
bruch = std.get_divers("bruch")
prec = std.get_prec(1)
if operation in ["+", "-"]:
operation = "+" if round(eval(f"{operation}{div}"), ) >= 0 else "-"
div = std.format_prec(div, prec, absval=True)
if bruch_zahl_1 is None or bruch_zahl_2 is None:
out = f"{std.roman(zeile_1)}. {operation} {div} ∙ {std.roman(zeile_2)}."
else:
pfeil = std.format_prec(
["", f"{std.roman(zeile_1)}. {operation} ", ""],
1,
string=True)
bruch_darst = std.format_prec([bruch_zahl_1, bruch_zahl_2],
bruch=True,
absval=True)
out = []
for a, b in zip(pfeil, bruch_darst):
out.append(a + b)
out = [
f"{item} ∙ {std.roman(zeile_2)}."
if i == 1 else f"{item}{' ' * (len(std.roman(zeile_2)) + 4)}"
for i, item in enumerate(out)
]
elif operation == "*":
if bruch_zahl_1 is None or bruch_zahl_2 is None:
div = std.format_prec(div, prec, klammer=True)
out = f"{std.roman(zeile_2)}. ∙ {div}"
else:
pfeil = std.format_prec(["", f"{std.roman(zeile_1)}. ∙ ", ""],
1,
string=True)
bruch_zahl_1 = (-1 if div < 0 else 1) * abs(bruch_zahl_1)
bruch_darst = std.format_prec(
[bruch_zahl_1, abs(bruch_zahl_2)], bruch=True, mehrere=True)
out = []
for a, b in zip(pfeil, bruch_darst):
out.append(a + b)
out = [
f"{item} ∙ {std.roman(zeile_2)}."
if i == 1 else f"{item}{' ' * (len(std.roman(zeile_2)) + 4)}"
for i, item in enumerate(out)
]
elif operation == "tausch":
out = [f"{std.roman(zeile_1)}. <─> {std.roman(zeile_2)}."]
return out
def lgs(inp,
prec,
b_len=1,
operation="+",
zeilen=False,
b_berechnen=False,
rev=False,
print_param_str=True,
color=None,
param_list=None,
print_param=True,
nach_KV_umstellen=False,
print_=True,
string_ausrichtung=None):
"""
Parameters
----------
inp Darzustellende Werte. Der letzte (b_len) wert wird als b interpretiert
prec Anzahl der Nachkommastellen
b_len Die länge von b
operation Welche Operation angezeigt (und ggf. per b_berechnen berchnet) wird
zeilen Soll inp als zeilen interpretiert werden?
b_berechnen Soll b berechnet werden
rev Soll b auf der linken Seite stehen?
print_param_str Soll bei leeren Strings die Parameter geprinted werden?
color In welcher Farbe soll alles angezeigt werden?
param_list Welche Parameter sollen angezeigt werden
print_param Sollen dei Parameter angezeigt werden
nach_KV_umstellen Soll nach den Kopfvariablen (einer Matrix) umgestellt werden?
print_ Soll der Output angezeigt werden?
string_ausrichtung Mit welcher Ausrichtung sollen die str angezeigt werden?
Returns
-------
list von Strings die geprinted werden
"""
inp = copy.deepcopy(inp)
if not isinstance(inp[0], list):
inp = [inp]
if zeilen is True:
inp = transp_ohne(inp)
else:
pass
# inp wird in Spaltenform bearbeitet
if b_berechnen:
inp.append([])
prec_1, prec_int = std.get_prec([1, "int"])
dim_n = len(inp[0]) # dim_n = Anzahl der Zeilen
dim_m = len(inp) # dim_m = Anzahl der Spalten
prec = std.prec_auffüllen(prec, dim_m)
if print_param:
if param_list is None:
param_list = []
for i in range(1, dim_m):
param_list.append(f" {std.übersetzung_zahl_param(i)}")
else:
for i, item in enumerate(param_list):
if item == "":
continue
if item[0] != " ":
param_list[i] = f" {item}"
if len(param_list) + 1 < dim_m:
i = len(param_list) + 1
while i < dim_m:
param_list.append(f" {std.übersetzung_zahl_param(i)}")
i += 1
param_list.append("")
else:
param_list = ["" for _ in range(dim_m)]
if b_berechnen:
neu_b = [
inp[0][i] if operation in ["+", "-", "/"] else 1
for i in range(dim_n)
]
start = 1 if operation in ["+", "-", "/"] else 0
for i in range(dim_n):
for j in range(start, dim_m - 1):
if operation == "+":
neu_b[i] += inp[j][i]
elif operation == "-":
neu_b[i] -= inp[j][i]
elif operation == "*":
neu_b[i] *= inp[j][i]
elif operation == "/":
if round(inp[j][i], prec_int) == 0:
if neu_b[i] == 0:
neu_b[i] = "*"
else:
neu_b[i] = 0
else:
neu_b[i] /= inp[j][i]
inp[-1] = neu_b
if nach_KV_umstellen:
n = find_NKV_ohne(ohne_b_ohne(inp, False), False)
neu_inp = [inp[i] for i in range(len(inp)) if i not in n]
neu_param = [param_list[i] for i in range(len(inp)) if i not in n]
for i in range(len(inp)):
if i in n:
neu_inp.append([-inp[i][j] for j in range(dim_n)])
neu_param.append(param_list[i])
inp = neu_inp
param_list = neu_param
b_len += len(n)
inp_darst, inp_darst_abs, inp_darst_vorne, inp_darst_klam = [], [], [], []
if string_ausrichtung is None:
string_ausrichtung = "rechts"
for i in range(dim_m):
inp_darst.append(
std.format_prec(inp[i],
prec[i],
True,
string_ausrichtung=string_ausrichtung))
inp_darst_abs.append(
std.format_prec(inp[i],
prec[i],
absval=True,
string_ausrichtung=string_ausrichtung))
inp_darst_vorne.append(
std.format_prec(inp[i],
prec[i],
vorne=True,
string_ausrichtung=string_ausrichtung))
inp_darst_klam.append(
std.format_prec(inp[i],
prec[i],
klammer=True,
string=True,
string_ausrichtung=string_ausrichtung))
if operation == "*":
nchk = ["∙" for _ in range(dim_n)]
elif operation == "/":
nchk = ["/" for _ in range(dim_n)]
if operation == "-":
for i in range(dim_n):
for j in range(1, dim_m - 1):
inp[j][i] *= -1
out = []
for i in range(dim_n):
# i = Counter über Zeilen
out.append("")
if rev:
out[i] += colored(f"{inp_darst_vorne[-1][i]} = ", color)
out[i] += colored(
f"{inp_darst_vorne[0][i]}{param_list[0] if print_param_str or inp_darst_vorne[0][i].strip() else ''}",
color)
for j in range(1, len(inp)):
# j = Counter über die Spalten
if operation in ["+", "-"]:
nchk = std.negcheck(inp[j][i])
if j >= dim_m - b_len:
if j == dim_m - b_len:
if not rev:
out[i] += colored(f" = {inp_darst_vorne[j][i]}", color)
else:
if nach_KV_umstellen:
if operation in ["+", "/"]:
out[i] += colored(
f" {nchk[0]} {inp_darst_abs[j][i]}{param_list[j] if print_param_str or inp_darst_abs[j][i].strip() else ''}",
color)
else:
out[i] += colored(
f" {nchk[0]} {inp_darst_abs[j][i]}{param_list[j] if print_param_str or inp_darst_abs[j][i].strip() else ''}",
color)
else:
if operation in ["+", "/"]:
out[i] += colored(
f" {nchk[0]} {inp_darst_klam[j][i]}{param_list[j] if print_param_str or inp_darst_klam[j][i].strip() else ''}",
color)
else:
out[i] += colored(
f" {nchk[0]} {inp_darst_abs[j][i]}{param_list[j] if print_param_str or inp_darst_abs[j][i].strip() else ''}",
color)
else:
if operation in ["*", "/"]:
out[i] += colored(
f" {nchk[0]} {inp_darst_klam[j][i]}{param_list[j] if print_param_str or inp_darst_klam[j][i].strip() else ''}",
color)
else:
out[i] += colored(
f" {nchk[0]} {inp_darst_abs[j][i]}{param_list[j] if print_param_str or inp_darst_abs[j][i].strip() else ''}",
color)
if print_:
for item in out:
print(item)
return out