Rechnen mit Zahlenreihen

Dieser Artikel erklärt, wie man mit Zahlenreihen in einem CSV-Datentyp rechnet und logische Operationen darauf anwendet, inklusive Beispielen für Funktionen wie Mittelwert, Standardabweichung, Addition, Multiplikation und bedingte Vergleiche.

Wenn man bei einem Parameter als Datentyp csv angibt, so kann man in ein Eingabefeld mehrere Werte hintereinander, als Zahlenreihe, eintragen.

Zahlenreihen werden in der Regel aus Messgeräten importiert, können aber auch manuell eingegeben werden (bei der manuellen Eingabe werden die einzelnen Werte mit der Enter-Taste getrennt eingetragen).

In der obigen Abbildung wurde die Zahlenreihe Brennrate aus der Zahlenreihe Brennstrecke und Brennzeit berechnet.
Brennrate = (Brennstrecke / Brennzeit)*60

Dabei wurde der 1. Wert der Brennstecke mit dem 1. Wert der Brennzeit dividiert und mit 60 multipliziert (254 / 202)*60 = 75,45
Der 2. Wert der Brennstecke mit dem 2. Wert der Brennzeit dividiert und mit 60 multipliziert (123 / 202)*60 = 36,53
usw.

Die Formel sieht folgendermaßen aus:

csvmultiply(csvdivide(m['BV']['1'], m['BV']['2']), 60)

Funktionen zum Rechnen mit Zahlenreihen

Funktion	Bezeichnung	Beispiel
mittelwert	`mittelwert(Zahlenreihe)` bildet den Mittelwert der Zahlenreihe	`mittelwert(m['BV']['1']) = mittelwert(254; 123; 100; 254; 254) = 197`
median	`median(Zahlenreihe)` bildet den Median der Zahlenreihe. Besteht die Zahlenreihe aus einer geraden Anzahl von Zahlen, berechnet median den Mittelwert der beiden mittleren Zahlen.	`median(m['BV']['1']) = 254`
stabw oder stabws	`stabw(Zahlenreihe)` bildet die Standardabweichung einer Stichprobe:	`stabw(m['BV']['1']) = 78,47`
stabwn	`stabwn(Zahlenreihe)` bildet die Standardabweichung einer Grundgesamtheit:	`stabwn(m['BV']['1']) = 70,19`
summe	`summe(Zahlenreihe)` bildet die Summe einer Zahlenreihe	`summe(m['BV']['1']) = 985`
produkt	`produkt(Zahlenreihe)` bildet das Produkt der Zahlenreihe	`produkt(m['BV']['1']) = 201560887200`
min	`min(Zahlenreihe)` gibt die kleinste Zahl der Zahlenreihe zurück	`min(m['BV']['1']) = 100`
max	`max(Zahlenreihe)` gibt die größte Zahl der Zahlenreihe	`max(m['BV']['1']) = 254`
first	`first(Zahlenreihe)` liefert den ersten Wert einer Zahlenreihe	`first(m['BV']['1']) = 254`
last	`last(Zahlenreihe)` liefert den letzten Wert einer Zahlenreihe	`last(m['BV']['1']) = 254`
csventry	`csventry(Position, Werte)` liefert den Werte an einer bestimmten Position einer Zahlenreihe. Wobei die Position bei 0 anfängt zu zählen.	z.B.: `csventry(this(1), this(0))` liefert folgendes Ergebnis:
csvadd	`csvadd(Zahlenreihe A, Zahlenreihe B)` addiert den 1. Wert der Zahlenreihe A zu dem 1. Wert der Zahlenreihe B, usw. und liefert wieder eine Zahlenreihe zurück	`csvadd(m['BV']['1'], m['BV']['2']) = 456; 325; 150; 456; 456`
csvminus	`csvminus(Zahlenreihe A, Zahlenreihe B)` subtrahiert den 1. Wert der Zahlenreihe A von dem 1. Wert der Zahlenreihe B, usw. und liefert wieder eine Zahlenreihe zurück	`csvminus(m['BV']['1'], m['BV']['2']) = 52; -79; 50; 52; 52`
csvmultiply	`csvmultiply(Zahlenreihe A, Zahlenreihe B)` multipliziert den 1. Wert der Zahlenreihe A mit dem 1. Wert der Zahlenreihe B, usw. und liefert wieder eine Zahlenreihe zurück	`csvmultiply(m['BV']['1'], m['BV']['2']) = 51308; 24846; 5000; 51308; 51308`
csvdivide	`csvdivide(Zahlenreihe A, Zahlenreihe B)` dividiert den 1. Wert der Zahlenreihe A mit dem 1. Wert der Zahlenreihe B, usw. und liefert wieder eine Zahlenreihe zurück	`csvdivide(m['BV']['1'], m['BV']['2']) = 1,26; 0,61; 2,00; 1,26; 1,26`
csvpow	`csvpow(Zahlenreihe A, Zahlenreihe B)` nimmt den 1. Wert Zahlenreihe A als Basis und dem 1. Wert der Zahlenreihe B als Potenz, usw. und liefert wieder eine Zahlenreihe zurück	`csvpow(10, 3) = 1000`
csvanzahl	`csvanzahl(Zahlenreihe)` liefert als Ergebnis die Anzahl der Zahlen in der Zahlenreihe	`csvanzahl(1,26; 0,61; 2,00; 1,26; 1,26) = 5`
csvverketten	`csvverketten(Zeichenreihe A, Zeichenreihe B)` erlaubt die Verkettung von zwei Zeichenreihen. Um mehrere Zeichenreihen zu verketten, kann diese Funktionen mehrmals ineinander verschachtelt werden: `csvverketten(Zeichenreihe A, csvverketten(Zeichenreihe B, Zeichenreihe C))`	`csvverketten(15; 16, 'mg/l') = 15mg/l; 16mg/l`
csvmittelwert	`csvmittelwert(Zahlenreihe A, Zahlenreihe B,...)` erlaubt die Berechnung des Mittelwertes je Zeile mehrerer Zahlenreihen.	`csvmittelwert(5;10,15;20) = 10;15`
csvmedian	`csvmedian(Zahlenreihe A, Zahlenreihe B,...)` erlaubt die Ermittlung des Medians je Zeile mehrerer Zahlenreihen. Bei einer geraden Anzahl von Zahlenreihen wird der Mittelwert der mittleren Werte gebildet.	`csvmedian(5;10,15;20,20;25) = 15;20`
csvstabw	`csvstabw(Zahlenreihe A, Zahlenreihe B,...)` Ermittelt die Standardabweichung je Zeile mehrerer Zahlenreihen.	`csvstabw(1;1,1.5;2,2;3) = 0.5;1`
csvstabwn	`csvstabwn(Zahlenreihe A, Zahlenreihe B,...)` Ermittelt die Standardabweichung nach Grundgesamtheit je Zeile mehrerer Zahlenreihen.	`csvstabwn(1;1,1.5;2,2;3) = 0.41;0.82`
csvstabws	`csvstabws(Zahlenreihe A, Zahlenreihe B,...)` Ermittelt die Standardabweichung nach Stichprobe je Zeile mehrerer Zahlenreihen.	`csvstabws(1;1,1.5;2,2;3) = 0.5;1`
csvround	`csvround(Zahlenreihe, Anzahl der Stellen)` Rundet einen Fließkommawert je Zeile einer Zahlenreihen.	`csvround(5.42;4.37,1) = 5.4;4.4`
csvroundsig	`csvroundsig(Zahlenreihe, Anzahl der signifikanten Stellen)` Rundet je Zeile eine Zahl auf die definierten signifikanten Stellen.	`roundsig(123; 12.3; 1.23; 0.123; 0.0123; 0.0123; 0.00123, 2) = 120.00; 12.00; 1.20; 0.12; 0.01; 0.01; 0.00; ``
csvlog	`csvlog(Zahlenreihe)` natürlicher Logarithmus je Zeile einer Zahlenreihen.	`csvlog(10;15) = 2.3026;2.7081`
csvlog10	`csvlog10(Zahlenreihe)` Logarithmus zur Basis 10 je Zeile einer Zahlenreihen.	`csvlog10(10;15) = 2.3026;2.7081`
csvexponentialformat	`csvexponentialformat(Zahlenreihe)` Die Zahlen werden je Zeile einer Zahlenreihen in Exponentialdarstellung (Wissenschaftliche Notation) mit einer Dezimalstelle angezeigt.	`csvexponentialformat(1005;3400) = 1,0 x 10^3;3,4 x 10^3`
csvlinks	`csvlinks(Zeichenreihe, Anzahl der Zeichen)` Zeichen von links abschneiden je Zeile einer Zahlenreihen.	`csvlinks(Hallo;Welt,3) = Hal;Wel`
csvrechts	`csvrechts(Zeichenreihe, Anzahl der Zeichen)` Zeichen von rechts abschneiden je Zeile einer Zahlenreihen.	`csvrechts(Hallo;Welt,3) = llo;elt`
csvmin	`csvmin(Zahlenreihe A, Zahlenreihe B, ...)` gibt zeilenweise den kleineren der beiden Werte aus Zahlenreihe A und Zahlenreihe B zurück	`csvmin(1;2;3, 3;2;1) = 1;2;1`
csvmax	`csvmax(Zahlenreihe A, Zahlenreihe B, ...)` gibt zeilenweise den größeren der beiden Werte aus Zahlenreihe A und Zahlenreihe B zurück	`csvmax(1;2;3, 3;2;1) = 3,2;3`
csvzahlenformat	`csvzahlenformat(Zahlenreihe, Dezimalstellen, Dezimalzeichen)` ⚠️ Achtung: Die Zahlen werden als String gespeichert. Soll mit diesen Zahlen weiter gerechnet werden, wird Komma nicht als Dezimaltrennzeichen erkannt und muss bei der Rechnung mit `csvwechseln()` durch einen Punkt ersetzt werden. Die Zahlen werden mit der Anzahl der Dezimalstellen und Dezimalzeichen angezeigt. Optional kann auch noch ein Tausendertrennzeichen definiert werden: `csvzahlenformat(Zahl, Dezimalstellen, Dezimalzeichen, Tausendertrennzeichen).	`csvzahlenformat(1.23; 234.12; 23.35; 1234567.35; 0.00, 2, '/', '$') = 1/23; 234/12; 23/35; 1$234$567/35; 0/00`
csvwechseln	`csvwechseln(Zahlenreihe, Alter Text, Neuer Text)` ersetzt je Zeile alten Text in der Zahlenreihe durch neuen Text	`csvwechseln(abcde; Tada; Blubb; 0.00, a, z) = zbcde; Tzdz; Blubb; 0.00`
csvasc	`csvasc(Zahlenreihe)` sortiert eine gemischte Zahlen- und Textreihe aufsteigend: zuerst die Zahlen numerisch aufsteigend, danach die Texte alphabetisch aufsteigend	`csvasc(3; 0; a; Hallo) = 0; 3; a; Hallo`
csvdesc	`csvdesc(Zahlenreihe)` sortiert eine gemischte Zahlen- und Textreihe absteigend: zuerst die Texte alphabetisch absteigend, danach die Zahlen numerisch absteigend	`csvdesc(3; 0; a; Hallo) = Hallo; a; 3; 0`
csvIstzahl	`csvIstzahl(Zahlenreihe)` prüft je Zeile, ob der Wert eine Zahl ist, und liefert 1 (Zahl) oder 0 (keine Zahl) zurück	`csvIstzahl(1; 1,23; 0; abc; pewpew; eins; 0) = 1; 1; 1; 0; 0; 0; 1`
csvabs	`csvabs(Zahlenreihe)` gibt je Zeile den Absolutbetrag einer Zahl zurück; bei nicht-numerischen Werten bleibt das Ergebnis leer	`csvabs(0; 12,34; 1,99; 1234,68; abc; pewpew) = 0; 12,34; 1,99; 1234,68; ;`
csvsqrt	`csvsqrt(Zahlenreihe)` gibt je Zeile die Quadratwurzel (gerundet auf 2 Nachkommastellen) einer Zahl zurück; bei nicht-numerischen Werten bleibt das Ergebnis leer	`csvsqrt(0; 1; 2; 12,34; 1,99; 1234,68; abc; pewpew) = 0; 1; 1,41; 3,51; 1,41; 35,14; ;`
csvlaenge	`csvlaenge(Text)` berechnet je Zeile, wieviele Zeichen im Text vorkommen	`csvlaenge(+++; Pew) = 3; 3`
csvwert	`csvwert(Text)` Verwandelt Text zeilenweise in eine Dezimalzahl.	`wert('< 0,25 mg/l'; >123; pew) = 0.25; 123; 0`

Durch Kombination der angeführten Funktion läßt sich die oben angeführte Berechnung der Brenngeschwindigkeit wiefolgt realisieren:

Brenngeschwindigkeit = csvmultiply(csvdivide(m['BV']['1'], m['BV']['2']), 60) = 75,45; 36,53; 120,00; 75,45; 75,45

Logische Operationen mit Zahlenreihen

Funktion	Bezeichnung	Beispiel
csvwenn	`csvwenn(Ausdruck, a, b)` prüft zeilenweise ob der Ausdruck (basierend auf dem `csvvergleicher`) 1 (wahr) oder 0 (falsch) ist und gibt dann die Zahl aus der Zahlenreihe a oder b wieder (a wenn der Wert wahr ist (1) und b wenn der Wert falsch ist (0)).	`csvwenn({0, 1, 1, 0},{1, 2, 3, 4},{55, 66, 77, 88}) = {55, 2, 3, 88}`
csvvergleich	`csvvergleich(a, Vergleichsoperator, b)` vergleicht zeilenweise a und b basierend auf dem Vergleichsoperator (>, <, <=, >=, !=, ==) und liefert 0 (false) oder 1 (true) zurück.	`csvvergleich({10, 11, 12, 13},'<',{12, 12, 12, 12})={1,1, 0, 0}`
csvund	`csvund(a, b)` bildet zeilenweise eine logische UND-Verknüpfung zwischen a und b. (Dient zum verknüpfen von zwei csvvergleichern innerhalb einer csvwenn abfrage)	`csvund({0, 0, 1, 1}, {0, 1, 0, 1}) = {0, 0, 0, 1}`
csvoder	`csvoder(a, b)` bildet zeilenweise eine logische ODER-Verknüpfung zwischen a und b. (Dient zum Verknüpfen mehrerer csvvergleiche innerhalb einer csvwenn abfrage)	`csvoder({0, 0, 1, 1}, {0, 1, 0, 1}) = {0, 1, 1, 1}`
csvinverter	`csvinverter(a)` invertiert a zeilenweise (aus 0 wird 1, aus 1 wird 0).	`csvinverter({0, 1, 1, 0}) = {1, 0, 0, 1}`

Beispiele zu den logischen Operationen mit Zahlenreihen

csvwenn und csvvergleich werden meist in der folgenden Kombination verwendet:

csvwenn(csvvergleich(a, Vergleichsoperator, b), a, b)

Wobei a und b eine Zahlenreihe ist und als Vergleichsoperator >, <, <=, >=, !=, == verwendet werden.

Nachfolgend ein Beispiel wie wir die Zahlenreihen a und b vergleichen und dann zeilenweise jeweils den größeren Wert zurückgeben:

a = {1, 3, 4}
b = {7, 1, -1}

csvwenn(csvvergleich(a, '>', b), a, b) = {7, 3, 4}

das Ergebnis kommt zustande, weil das Ergebnis des csvvergleich wie folgt aussieht
csvvergleich({1, 3, 4}, '>', {7, 1, -1}) = {0, 1, 1}

Anwendungsbeispiel csvund
→ csvund setzt voraus, dass die beiden csvvergleicher zutreffen
csvwenn( csvund( csvvergleich(a, ’>’ , 0), csvvergleich(b, ‘>’, 0) ), ‘<0’, csvadd(a,b) ) = {8, 4, ‘<0’}