zur Übersicht nächste Seite

Addition von Brüchen

Die Ausführungen der vorherigen Seiten über Programmfenster werden hier weitergeführt.
Generell gilt bei den weißen Textstellen auf dieser Seite: Man fügt die Zeichenfolge aus dem weißen Feld bei dem blinkenden Cursor des Terminals ein - dann drückt man die Eingabetaste. 
Oder man fügt die Zeichenfolge aus dem weißen Feld bei dem blinkenden Cursor des Editors ein.  
Dann drückt man zum Abspeichern gleichzeitig Strg und O 
dann drückt man die Eingabetaste um den Dateinamen zu bestätigen 
dann drückt man zum Verlassen des Editors gleichzeitig Strg und X.


Rechnen in bash: Schreibt man Zahlen mit den üblichen Rechenoperationen + - / * in doppelte Klammern (( )) so kann man damit rechnen - soweit es sich um positive oder negative ganze Zahlen handelt. Es sind keine Kommazahlen oder Punktzahlen erlaubt - diese kann man mit dem Programm bc berechnen.
echo $(( 2-(25-5)+4 ))
-14
echo $(( 25/3 ))
8

Wie bei bc ohne Zusatzoption werden nur ganze Zahlen ausgegeben - der Rest wird verschluckt. Aber es gibt eine Berechnungsmöglichkeit für den Rest
echo $(( 25%3 ))
1
echo 25/3 = $(( 25/3 )) Rest $(( 25%3 ))
25/3 = 8 Rest 1

Damit öffnet sich eine Möglichkeit für die Bruchrechnung.
Mit Variablen schreibt sich dies
Zaehler=25

Nenner=3

echo $Zaehler/$Nenner = $(( $Zaehler/$Nenner )) + $(( $Zaehler%$Nenner ))/$Nenner
25/3 = 8 + 1/3

Innerhalb der (( )) darf man bei Variablen $ weglassen, also 
a statt $a 
schreiben. Bei der Multiplikation zeigt sich ein kleiner Stolperstein
echo $(( 90000000000*100000000 ))
9000000000000000000

Aber bei einer Null mehr
echo $(( 90000000000*1000000000 ))
-2233720368547758080

Wenn die Zahlen zu viele Stellen haben (Grenze ist wohl bei 19 Stellen), kapituliert diese Rechenmethode.

Und man kann mit (( )) Vergleiche durchführen
Ne=17424

Za=8712

if (( $Za%$Ne==0 )); then echo ohne Rest teilbar; else echo Rest ist $(( $Za%$Ne )); fi
Rest ist 8712

Im Internet habe ich eine Funktion gefunden die den größten gemeinsamen Teiler nach dem euklidischen Algorithmus berechnet. Damit läßt sich ein script schreiben zum Addieren von Brüchen. Die Multiplikation aller Nenner und Zähler darf die Stellenzahl von 18 nicht überschreiten. 
Beim Aufrufen des scriptes öffnet sich ein yad-Fenster in das man Werte eingeben kann. Es können auch negative Brüche eingegeben werden.

Nach dem Drücken der OK-Schaltfläche erhält man das Ergebnis

Man kann auch nur einen Bruch eingeben und damit diesen kürzen - die anderen Eingabefelder bleiben leer.

Man kann schnell eine Dezimalzahl in einen Bruch verwandeln. Z.B. 
9,368 = 9368/1000 oder auch = 9/1  + 368/1000

Das yad-Fenster enthält eine Bild-Datei die Sie auf Ihren Computer kopieren müssen. Diese Bild-Datei muß in dem selben Ordner liegen in dem auch das script abgelegt wird.

Das script wird wieder in dem Ordner ~/Bla abgelegt:
nano ~/Bla/BruchADDITION.sh
Eingabe in den Editor
#!/bin/bash

Uu=$(whoami)

yA=$(yad --title="Addition von Brüchen" --width=400 --on-top --columns="1" --form --image-on-top --image-path=/home/$Uu/Bla/ --image=bruch.png --align=center --field=" 1. Bruch":CE --field=" 2. Bruch":CE --field=" 3. Bruch":CE --field=" 4. Bruch":CE --field=" 5. Bruch":CE --field=" 6. Bruch":CE--button="Berechnen" 2> /dev/null)

if (( $? != 0 )); then
exit
fi

if grep , <<< "$( echo "$yA" | sed 's/\./,/g' )"; then zenity --info --width="280" --title="Fehler" --text "Eingabedaten dürfen \n\n keine Kommazahlen sein"
exit
fi

if ! (( $( echo "$yA" | sed 's/[/|-]//g' | sed 's/+//g' ) )); then zenity --info --width="280" --title="Fehler" --text "Eingabedaten müssen \n\n ganze Zahlen sein"
exit
fi

IFS="|" read Br1 Br2 Br3 Br4 Br5 Br6 <<< "$( echo $yA | sed 's/+//g' )"

if [[ ! $Br1 ]]; then Bz1=0; Bn1=1
else
Bz1=$(echo $Br1 | sed s'/\/.*$//')
Bn1=$(echo $Br1 | sed s'/^.*\///')
fi
if [[ ! $Br2 ]]; then Bz2=0; Bn2=1
else
Bz2=$(echo $Br2 | sed s'/\/.*$//')
Bn2=$(echo $Br2 | sed s'/^.*\///')
fi
if [[ ! $Br3 ]]; then Bz3=0; Bn3=1
else
Bz3=$(echo $Br3 | sed s'/\/.*$//')
Bn3=$(echo $Br3 | sed s'/^.*\///')
fi
if [[ ! $Br4 ]]; then Bz4=0; Bn4=1
else
Bz4=$(echo $Br4 | sed s'/\/.*$//')
Bn4=$(echo $Br4 | sed s'/^.*\///')
fi
if [[ ! $Br5 ]]; then Bz5=0; Bn5=1
else
Bz5=$(echo $Br5 | sed s'/\/.*$//')
Bn5=$(echo $Br5 | sed s'/^.*\///')
fi
if [[ ! $Br6 ]]; then Bz6=0; Bn6=1
else
Bz6=$(echo $Br6 | sed s'/\/.*$//')
Bn6=$(echo $Br6 | sed s'/^.*\///')
fi

Hr=$( echo $(( Bn1*Bn2*Bn3*Bn4*Bn5*Bn6 )) )

if (( $Hr == 0 )); then zenity --info --width="280" --title="Fehler" --text "Teilen durch Null \n\n ist nicht erlaubt"
exit
fi

Zr=$( echo $(( Bz1*Bn2*Bn3*Bn4*Bn5*Bn6 +Bz2*Bn1*Bn3*Bn4*Bn5*Bn6 +Bz3*Bn1*Bn2*Bn4*Bn5*Bn6+Bz4*Bn1*Bn2*Bn3*Bn5*Bn6 +Bz5*Bn1*Bn2*Bn3*Bn4*Bn6+Bz6*Bn1*Bn2*Bn3*Bn4*Bn5 )) )

Aufgabe=$(echo $Bz1/$Bn1 + $Bz2/$Bn2 + $Bz3/$Bn3 + $Bz4/$Bn4 + $Bz5/$Bn5 + $Bz6/$Bn6 = | sed s'# + 0/1##g' | sed s'#+ -#-#g')

gcd() { ! (( $1 % $2 )) && echo $2 || gcd $2 $(( $1 % $2 )); }

ggT=$(gcd $(echo $Zr | sed 's/-//') $(echo $Hr | sed 's/-//'))

Z/N () { if (( $1%$2==0 )); then echo $1/$2 = $(( $1/$2 )); else echo $1/$2 = $(( $1/$2 )) + $(( $1%$2 ))/$2 ; fi; }

zenity --info --width="450" --icon-name=emblem-default --title="Ergebnis der Addition der Brüche" --text "$Aufgabe \n\n $(Z/N $(( Zr/ggT )) $(( Hr/ggT )) | sed s'#+ -#-#g')"
Nun muß man das script ausführbar machen.
chmod +x ~/Bla/BruchADDITION.sh


zur Übersicht nächste Seite

Datenschutzerklärung
Impressum