Formeln bei Parametern hinterlegen

Die Labordatenbank bietet ein Formelsystem zur Berechnung von Parametern.

1. Formelsystem: Vektorschreibweise

Beispiel: A = B + C und D = A * 2

Die Buchstaben A-D stehen hier stellvertretend für die Kurzbezeichnung des jeweiligen Parameters => v['Abkürzung']. Diese wird in der Parameterverwaltung an zweiter Stelle unter „Abkürzung“ definiert und für die Vektorschreibweise zwingend benötigt (siehe Anleitung: Parameter anlegen).

Um diese beiden Formeln in der Labordatenbank abzubilden, tragen Sie bei Parameter A die Formel v['B']+v['C'] ein (die Vektorschreibweise v['B'] steht für den Parameter B). Das berechnete Ergebnis einer Formel (in diesem Fall Parameter A) kann auch selbst wieder in einer Formel weiterverwendet werden (z.B. in der Formel D = v['A']*2).

In der nachfolgenden Abb. sehen Sie, wie aus den bei B und C eingetragenen Werten (8 und 4) die Werte für A und D (12 und 24) automatisch berechnet werden.

2. Formelsystem: Matrixschreibweise

Bei einem Parameter können bis zu 10 Spalten hinterlegt werden. Die Matrixschreibweise beginnt bei 0 zu zählen somit ergibt das die Spalten 0 bis Spalte 9. Mit der Matrixschreibweise können Sie die Werte von allen Spalten in Ihren Formeln verwenden.

In der nächsten Abb. sehen Sie den Parameter TS mit vier Spalten (Ergebnis, Schale, Einwaage, Auswaage).

Schale, Einwaage und Auswaage werden eingetragen und das Ergebnis wird mit folgender Formel berechnet: ((Auswaage - Schale) / (Einwaage - Schale)) * 100

Wenn Sie in einer Formel den Wert der Spalte 0 (Ergebnis) verwenden möchten, so können Sie die Vektorschreibweise v['TS'] oder die Matrixschreibweise m['TS']['0'] verwenden (das Ergebnis ist das Gleiche).

Wenn Sie den Wert der Spalten 1, 2,... (Schale, Einwaage,...) verwenden möchten, so ist die Matrixschreibweise zu verwenden (m['TS']['1'] für Schale, m['TS']['2'] für Einwaage,...).

Beispiel: Ergebnis = ((Auswaage - Schale) / (Einwaage - Schale)) * 100

In diesem Bespiel steht das Ergebnis in der 0. Spalte, Schale in der 1. Spalte, Einwaage in der 2. Spalte und Auswaage in der 3. Spalte.

Somit ergibt sich folgende Schreibweise für diese Formel: TS = ((m['TS']['3'] - m['TS']['1']) / (m['TS']['2'] - m['TS']['1'])) * 100

2a. vereinfachtes Formelsystem: Parameter-interne Berechnungen

Sollten Sie ausschließlich innerhalb eines Parameters Berechnungen durchführen müssen, bietet sich die vereinfachte Schreibweise mit this(x) an. Mit dieser Vereinfachung können Sie die erstellte Formel problemlos auf andere Parameter übertragen, ohne für jeden Parameter die Matrixschreibweise anzupassen.

this(x) mit x= Spaltennummer.

Somit ergibt sich folgende Schreibweise für die obige Formel: TS = (this(3) - this(1)) / (this(2) - this(1))) * 100

2b. vereinfachtes Formelsystem: Berechnungen mit Sollwerten

Wollen Sie mit Sollwerten in Ihren Formeln rechnen, geben Sie sollwert(x) mit x= Spaltennummer, ein. Diese Formel hat dann Zugriff auf den bei der jeweiligen Spalte x hinterlegten Sollwert dieses Parameters. (Anleitung: Wie Sie Sollwerte hinzufügen.)

3. Formel anlegen

Formeln werden in der Maske Parameter bearbeiten angelegt.

In der Abb. oben steht die Formel 100 - m['TS']['1'], d.h. 100 minus TS-Wert der 1. Spalte.

Wenn wir bei diesem Beispiel in der Probendetaillansicht in der Spalte Eingabe den Wert 12 eintragen, so erhalten wir automatisch in der Spalte Report das Ergebnis 88 (siehe Abb. unten).

4. Verfügbare Funktionen in Parameterformeln

Funktion	Bezeichnung	Beispiel
abs	Absolutbetrag	`abs(-2) = 2`
mittelwert	Mittelwert	`mittelwert(3, 3, 6) = 4`
geomittel	Gibt das geometrische Mittel zurück.	`geomittel(3, 3, 6) = 3,78`
median	Median	`median(3, 3, 6) = 3`
min	Minimalwert bestimmen	`min(1, 3, 5, 6, 7) = 1`
max	Maximalwert bestimmen	`max(1, 3, 5, 6, 7) = 7`
stabw	`stabw(Zahl 1, Zahl 2,...)` Ermittelt die Standardabweichung	`stabw(1, 1.5, 2) = 0.50`
stabwn	`stabwn(Zahl 1, Zahl 2,...)` Ermittelt die Standardabweichung nach Grundgesamtheit	`stabwn(1, 1.5, 2) = 0.41`
stabws	`stabws(Zahl 1, Zahl 2,...)` Ermittelt die Standardabweichung nach Stichprobe	`stabws(1, 1.5, 2) = 0.50`
summe	`summe(Zahl 1, Zahl 2,...)` Addiert die zugehörigen Argumente	`summe(1, 3, 5, 6, 7) = 22`
produkt	`produkt(Zahl 1, Zahl 2,...)` Multipliziert die zugehörigen Argumente	`produkt(1, 3, 5, 6, 7) = 630`
potenz	`potenz(Basis, Exponent)` Potenzfunktion	`potenz(2, 5) = 32`
sqrt	Quadratwurzel	`sqrt(9) = 3`
exp	Exponentialfunktion	`exp(5.7) = 298.87`
log	natürlicher Logarithmus	`log(12) = 2.4849`
log10	Logarithmus zur Basis 10	`log10(100) = 2`
wenn	`wenn(Bedingung, dann, sonst)` Wenn die Bedingung TRUE ist, wird der dann-Teil zurückgegeben. Wenn nicht, der sonst-Teil.	`wenn(2 > 3, 1, 2) = 2` `wenn(5 > 3 && 9 < 12, 'passed', 'failed') = passed`
wenns	`wenns(Bedingung, dann, Bedingung, dann, [...], sonst)` Wenn die Bedingung TRUE ist, wird der dann-Teil zurückgegeben. Wenn nicht, wird überprüft, ob die nächste Bedingung TRUE ist und der nächste dann-Teil zurückgegeben. Wenn keine Bedignung TRUE ist, wird der sonst-Teil zurückgegeben.	`wenns( v['pH'] < 3, 'sehr sauer', v['pH'] < 6, 'sauer', v['pH'] < 8, 'neutral', 'alkalisch')`
ifselected	`ifselected(Parameterabkürzung, dann, sonst)` Wenn der Parameter mit dieser Parameterabkürzung bei der Probe ausgewählt ist, wird der dann-Teil zurückgegeben. Wenn nicht, der sonst-Teil.	`ifselected('pH', v['pH']*100, 'pH-Wert fehlt')`
links	`links(Text, Anzahl Zeichen)` Zeichen von links abschneiden	`links('123-456', 3) = 123`
rechts	`rechts(Text, Anzahl Zeichen)` Zeichen von rechts abschneiden	`rechts('123-456', 3) = 456`
wechseln	`wechseln(Text, Alter Text, Neuer Text)` Ersetzt alten Text durch neuen Text in einer Zeichenfolge	`wechseln(123456, 3, '-') = 12-456`
enthaelt	`enthaelt(Text, Suchbegriff)` Die Funktion prüft ob der Suchbegriff im Text enthalten ist.	`enthaelt('Hello World', 'World') = true`
beginntmit	`beginntmit(Text, Suchbegriff)` Die Funktion prüft ob der Text mit dem Suchbegriff beginnt.	`beginntmit('Hello World', 'World') = false`
endetmit	`endetmit(Text, Suchbegriff)` Die Funktion prüft ob der Text mit dem Suchbegriff endet.	`endetmit('Hello World', 'World') = true`
klein	`klein(Text)` Ersetzt Großbuchstaben durch Kleinbuchstaben.	`klein('ABcd') = 'abcd'`
gross	`gross(Text)` Ersetzt Kleinbuchstaben durch Grossbuchstaben.	`gross('ABcd') = 'ABCD'`
verketten	`verketten(Text, Text,...)` Erlaubt die Verkettung von mehreren Texten oder Zahlen	`verketten('abc ', 3) = abc 3`
laenge	`laenge(Text)` berechnet wieviele Zeichen im Text vorkommen	`laenge('+++') = 3`
sin	Sinus des Winkels	`sin(60) = -0.3048...`
cos	Kosinus des Winkels	`cos(3.1415) = -1`
tan	Tangens des Winkels	`tan(4) = 1.16`
asin	Arkussinus des Parameters (die Umkehrfunktion von `sin()`)	`asin(-1) = -1.571...`
acos	Arkuskosinus des Parameters (die Umkehrfunktion von `cos()`)	`acos(-0.5) = 2.094...`
atan	Arkustangens des Parameters (die Umkehrfunktion von `tan()`)	`atan(1) = 0.785...`
runden	`runden(Zahl, Anzahl der Stellen)` Rundet einen Fließkommawert	`runden(3.4) = 3` `runden(1234.567, 2) = 1234.57` `runden(1234.567, -2) = 1200`
aufrunden	`aufrunden(Zahl, Anzahl der Stellen)` Rundet einen Fließkommawert auf	`aufrunden(3.4) = 4` `aufrunden(1234.567, 2) = 1234.57` `aufrunden(1234.567, -2) = 1300`
abrunden	`abrunden(Zahl, Anzahl der Stellen)` Rundet einen Fließkommawert ab	`abrunden(3.4) = 3` `abrunden(1234.567, 2) = 1234.56` `abrunden(1234.567, -2) = 1200`
vrunden	`vrunden(Zahl, Vielfaches)` Gibt eine auf das gewünschte Vielfache gerundete Zahl zurück.	`vrunden(10, 3) = 9` `vrunden(1.3, 0.2) = 1.4` `vrunden(12.34, 0.05) = 12,35`
roundsig	`roundsig(Zahl, Anzahl der signifikanten Stellen)` Rundet eine Zahl auf die definierten signifikanten Stellen.	`roundsig(0.012345, 3) = 0,0123` `roundsig(12345, 3) = 12300`
wert	`wert(Text)` Verwandelt Text in eine Dezimalzahl.	`wert('< 0,25 mg/l') = 0.25`
fmod	`fmod(Dividend, Divisor)` Rest einer Fließkommadivision	`fmod(5.7, 1.3) = 0.5` weil 4 * 1.3 + 0.5 = 5.7
rand	`rand(min, max)` Erzeugt eine zufällige Zahl	`rand(5, 15) = 11`
zahlenformat	`zahlenformat(Zahl, Dezimalstellen, Dezimalzeichen, Tausendertrennzeichen)` Die Zahl wird mit der Anzahl der Dezimalstellen und Dezimalzeichen angezeigt. Optional kann auch noch ein Tausendertrennzeichen definiert werden: zahlenformat(Zahl, Dezimalstellen, Dezimalzeichen, Tausendertrennzeichen). Achtung: Die Zahl wird als String gespeichert. Soll mit dieser Zahl weiter gerechnet werden, wird Komma nicht als Dezimaltrennzeichen erkannt und muss bei der Rechnung mit`wechseln` durch einen Punkt ersetzt werden.	`zahlenformat(1995, 2, ',', '.') = 1.995,00`
exponentialformat	`exponentialformat(Zahl, Dezimalstellen)` Die Zahl wird in Exponentialdarstellung (Wissenschaftliche Notation) angezeigt.	`exponentialformat(1995, 1) = 2,0 x 10³`
istzahl	`istzahl(Wert)`Diese Funktion prüft ob es sich bei dem Wert um eine Zahl handelt.	`istzahl(12.34) = TRUE` `istzahl(12,34) = TRUE` `istzahl('hallo') = FALSE`
finden	`finden('suchtext',Wert)`Diese Funktion findet einen Textteil und gibt die Position zurück. Wird nichts gefunden, so wird ein Leerstring '' zurückgegeben.	`finden('.', '1234.de') = 5` `finden('-',12-34) = 3` `finden('welt', 'hallo welt') = 7`

Das Rufzeichen ! liefert für alle Funktionen die Negation. Es kann damit z.B. bei einer Abfrage wie istzahl(Wert), die TRUE ausgibt, wenn es sich um eine Zahl handelt, die Negation !istzahl(Wert) benutzt werden, so dass FALSE ausgegeben wird.

Weitere Funktionen finden Sie in der Anleitung Rechnen mit Zahlenreihen

5. Operatoren für die wenn-Funktion

Beispiel: Warnung bei einem pH-Wert kleiner 7 oder größer 13:

wenn(v['pH'] < 7 || v['pH'] > 13, 'ph-Wert nicht in Ordnung', 'pH-Wert in Ordnung')

Hier wurden zwei Vergleichsoperatoren (kleiner 7, größer 13) miteinander oder-verknüpft (|| ist der logische Operator Oder).

Vergleichsoperatoren

Beispiel	Name	Ergebnis
`A == B`	Gleich	Gibt TRUE zurück, wenn A gleich B ist.
`A != B`	Ungleich	Gibt TRUE zurück, wenn A nicht gleich B ist.
`A < B`	Kleiner Als	Gibt TRUE zurück, wenn A kleiner als B ist.
`A > B`	Größer Als	Gibt TRUE zurück, wenn A größer als B ist.
`A <= B`	Kleiner Gleich	Gibt TRUE zurück, wenn A kleiner oder gleich B ist.
`A >= B`	Größer Gleich	Gibt TRUE zurück, wenn A größer oder gleich B ist.

Logische Operatoren

Beispiel	Name	Ergebnis
`A && B`	Und	Gibt TRUE zurück, wenn sowohl A als auch B TRUE ist.
`A \|\| B`	Oder	Gibt TRUE zurück, wenn A oder B TRUE ist.
`A xor B`	Entweder Oder	Gibt TRUE zurück, wenn A oder B TRUE ist, aber nicht beide.
`!A`	Nicht	Gibt TRUE zurück, wenn A nicht TRUE ist.

Beispiel: Verschachtelung von zwei wenn-Funktionen:

wenn(v['pH'] < 7, 'ph-Wert zu niedrig', wenn(v['pH'] > 13, 'pH-Wert zu hoch', 'pH-Wert in Ordnung'))

Hier sind zwei wenn-Funktionen ineinander verschachtelt. Ist der pH-Wert kleiner 7, so wird 'pH-Wert zu niedrig' ausgegeben. Ist der pH-Wert größer oder gleich 7 so greift die zweite wenn-Funktion und prüft, ob der pH-Wert größer 13 ist. Wenn ja, wird 'pH-Wert zu hoch' ausgegeben, wenn nicht, wird 'pH-Wert in Ordnung'.

In dieser Form können beliebig viele wenn-Funktionen ineinander verschachtelt werden.

Beispiel: Verschachtelung von drei qualitativen Abfragen:

wenn(v['Farbe'] == 'rot', 'Die Farbe ist rot.', wenn(v['Farbe'] == 'gelb', 'Die Farbe ist gelb.',

wenn(v['Farbe'] == 'orange', 'Die Farbe ist orange.', 'Die Farbe ist undefiniert.')))

Letzte Änderung: 02.09.2024

Allgemeines

Einführungsphase

Mitarbeiter

Aufträge

Proben

Probenvorlage

Berichte

Berichtstabellen Editor

Kunden

Kundenzone (optional)

Anlagen

Angebote

Rechnungen

Parameter

Rechnen mit Parametern

Schnittstellen

Webservice

Transformationscode

Prüfpläne / Grenzwerte / Spezifikationen

Dokumentenlenkung

Prüfmittel

Material

Mitarbeiterschulungen

8D-Report

8D-Report anlegen

Sonstiges

Barcode / QR-Code Scanner

PDF-Vorlagen

Fragen und Antworten

Lieferantenbewertung

Dateiverwaltung

Auswertungen

Prozesse

Prozessmanagement