PMS32 Online- Hilfereferenz
Mathe - Mathematische- und Zahlenfunktionen
Mathematische- und Zahlenfunktionen
*/ Kurzbeispiel für den Zugriff auf diese Struktur */ Der Zugriff erfolgt über: My.Functions.Mathe */ Wird dieses Objekt in einem REPLACE oder einer Schleife SCAN ... ENDSCAN | FOR ... NEXT benötigt */ so sollte vor der Schleife die Objektstruktur in eine Variable geholt werden! */ Die Ausführungsgeschwindigkeit wird dadurch sehr vergrößert! */ Beispiel: */ Definieren einer LOKALEN Variablen LOCAL loMathe AS My.Functions.Mathe */ Setzen der Variablen loMathe = My.Functions.Mathe */ Jetzt erst die Schleifen durchlaufen... man beachte ALL, dass können ne Menge Sätze sein... REPLACE ALL Feldname1 WITH loMathe.Function1(),Feldname2 WITH loMathe.Function1(), ... */ Oder in einer Schleife... SCAN lvValue = loMathe.Function(Alias.Spalte) + 25 lvValue = loMathe.Function2(m.lvValue) REPLACE Feldname WITH m.lvValue,... ENDSCAN */ Es sind auch geschachtelte Aufrufe möglich...
Number = My.Functions.Mathe.AAvg(taArray , tiColumn AS Integer) Number = My.Functions.Mathe.AAvg(taArray,tiColumn)
LOCAL loMathe AS pmsmathe OF vcx\pmsmyfunctions.vcx , laZahlen[2,1] loMathe = My.Functions.Mathe laZahlen[1,1] = 2 laZahlen[2,1] = 4 WAIT WINDOW loMathe.AAvg(@laZahlen,1) && Shows '3'
Variant = My.Functions.Mathe.AMax(taArray , tiColumn AS INTEGER) Variant = My.Functions.Mathe.AMax(taArray,tiColumn)
LOCAL loMathe , laZahlen[2,1] loMathe = My.Functions.Mathe laZahlen[1,1] = 2 laZahlen[2,1] = 4 WAIT WINDOW loMathe.AMax(@laZahlen,1) && Shows '4'
Variant = My.Functions.Mathe.AMin(taArray , tiColumn AS INTEGER) Variant = My.Functions.Mathe.AMin(taArray,tiColumn)
LOCAL loMathe , laZahlen[2,1] loMathe = My.Functions.Mathe laZahlen[1,1] = 2 laZahlen[2,1] = 4 WAIT WINDOW loMathe.AMin(@laZahlen,1) && Shows '2'
Number = My.Functions.Mathe.ASum(taArray , tiColumn AS INTEGER) Number = My.Functions.Mathe.ASum(taArray,tiColumn)
LOCAL loMathe , laZahlen[2,1] loMathe = My.Functions.Mathe laZahlen[1,1] = 2 laZahlen[2,1] = 4 WAIT WINDOW loMathe.ASum(@laZahlen,1) && Shows '6'
Rückgabe: [Number], Wandel einen Binärwert (zeichen) in einen Dezimalwert um, aus chr(1) wird Dezimal 1 chr(31), parameter 2: 0=Intel:lowbyte,Hightbyte; 1=HightByte,LowByte
Number = My.Functions.Mathe.Bin2Dec(tcBin AS STRING, tlHightByteLowByte AS Boolean) Number = My.Functions.Mathe.Bin2Dec(tcBin,tlHightByteLowByte)
LOCAL loMathe loMathe = My.Functions.Mathe WAIT WINDOW loMathe.Bin2Dec(CHR(1)+CHR(35),.F.) && Shows 8961 L/H WAIT WINDOW loMathe.Bin2Dec(CHR(1)+CHR(35),.T.) && Shows 291 H/L
SyncSafe: Bit7 ist immer 0 aus 32 Bit werden effektiv 28
Variant = My.Functions.Mathe.Bin2DecSS(tcBin AS String) Variant = My.Functions.Mathe.Bin2DecSS(tcBin)
LOCAL loMathe loMathe = My.Functions.Mathe WAIT WINDOW loMathe.Bin2DecsS(CHR(1)+CHR(35)) && Shows 163
Rückgabe: [Variant], Umwandlung eines Binärwertes dessen Bytewerte zwischen 0x00 und 0x0F liegen in einen Zeichenwert bzw. eine Nummer
Variant = My.Functions.Mathe.Bin2Digit(tcBin AS STRING, tlHightByteLowByte AS Boolean, tlAlwaysString AS Boolean) Variant = My.Functions.Mathe.Bin2Digit(tcBin,tlHightByteLowByte,tlAlwaysString)
LOCAL loMathe loMathe = My.Functions.Mathe WAIT WINDOW loMathe.Bin2Digit(CHR(10),.F.,.F.) && Shows 'A'
Rückgabe: [String], Umwandlung eines Binärwertes in eine Dualzahl
String = My.Functions.Mathe.Bin2Dual(tcBin AS STRING , tiLen AS INTEGER) String = My.Functions.Mathe.Bin2Dual(tcBin,tiLen)
LOCAL loMathe loMathe = My.Functions.Mathe WAIT WINDOW loMathe.Bin2Dual(CHR(10),4) && Shows '1010'
Rückgabe: [String], Wandelt einen Binärwert in eine hexadezimale Zahl um
String = My.Functions.Mathe.Bin2Hex(tcBin AS STRING , tiLen AS INTEGER , tlHightByteLowByte AS Boolean) String = My.Functions.Mathe.Bin2Hex(tcBin,tiLen,tlHightByteLowByte)
LOCAL loMathe loMathe = My.Functions.Mathe WAIT WINDOW loMathe.Bin2Hex(CHR(10),2,.F.) && Shows '0A'
Syncsafe
Variant = My.Functions.Mathe.Bin2HexSS(tcBin AS STRING , tiLen AS INTEGER) Variant = My.Functions.Mathe.Bin2HexSS(tcBin,tiLen)
LOCAL loMathe loMathe = My.Functions.Mathe WAIT WINDOW loMathe.Bin2HexsS(CHR(134),2) && Shows '06'
Rückgabe: [Number], Wandelt einen Binärwert in eine num. Zahl um.
Number = My.Functions.Mathe.Bin2Num(tcZahl AS STRING) Number = My.Functions.Mathe.Bin2Num(tcZahl)
LOCAL loMathe loMathe = My.Functions.Mathe WAIT WINDOW loMathe.Bin2Num(CHR(134)) && Shows 134
Rückgabe: [Char], BITAND() zweier CHAR Binärwerte
Char = My.Functions.Mathe.BinAnd(tcBin1 AS STRING, tcBin2 AS STRING) Char = My.Functions.Mathe.BinAnd(tcBin1,tcBin2)
LOCAL loMathe loMathe = My.Functions.Mathe WAIT WINDOW ASC(loMathe.BinAnd(CHR(10),CHR(8))) && Shows CHR(8)
Rückgabe: [Char], BITCLEAR() eines CHAR Binärwertes
Char = My.Functions.Mathe.BinClear(tcBin AS STRING, tiBit AS INTEGER) Char = My.Functions.Mathe.BinClear(tcBin,tiBit)
LOCAL loMathe loMathe = My.Functions.Mathe WAIT WINDOW ASC(loMathe.BinClear(CHR(10),1)) && Shows CHR(8)
Rückgabe: [Char], BITLSHIFT() eines CHAR Binärwertes
Char = My.Functions.Mathe.BinLShift(tcBin AS STRING, tiBits AS INTEGER) Char = My.Functions.Mathe.BinLShift(tcBin,tiBits)
LOCAL loMathe loMathe = My.Functions.Mathe WAIT WINDOW ASC(loMathe.BinLShift(CHR(10),2)) && Shows 0
Rückgabe: [Char], BITNOT() eines CHAR Binärwertes
Char = My.Functions.Mathe.BinNot(tcBin AS STRING) Char = My.Functions.Mathe.BinNot(tcBin)
LOCAL loMathe loMathe = My.Functions.Mathe WAIT WINDOW ASC(loMathe.BinNot(CHR(10))) && Shows 5
Rückgabe: [Char], BITOR() zweier CHAR Binärwerte
Char = My.Functions.Mathe.BinOr(tcBin1 AS STRING, tcBin2 AS STRING) Char = My.Functions.Mathe.BinOr(tcBin1,tcBin2)
LOCAL loMathe loMathe = My.Functions.Mathe WAIT WINDOW ASC(loMathe.BinOr(CHR(10),CHR(5))) && Shows 15
Rückgabe: [Char], BITRSHIFT() eines CHAR Binärwertes
Char = My.Functions.Mathe.BinRShift(tcBin AS STRING, tiBits AS INTEGER) Char = My.Functions.Mathe.BinRShift(tcBin,tiBits)
LOCAL loMathe loMathe = My.Functions.Mathe WAIT WINDOW ASC(loMathe.BinRShift(CHR(10),2)) && Shows 2
Rückgabe: [Char], BITSET() eines CHAR Binärwertes
Char = My.Functions.Mathe.BinSet(tcBin AS STRING, tiBit AS INTEGER) Char = My.Functions.Mathe.BinSet(tcBin,tiBit)
LOCAL loMathe loMathe = My.Functions.Mathe WAIT WINDOW ASC(loMathe.BinSet(CHR(10),2)) && Shows 14
Rückgabe: [Boolean], BITTTEST() eines CHAR Binärwertes
Boolean = My.Functions.Mathe.BinTest(tcBin AS STRING, tiBit AS INTEGER) Boolean = My.Functions.Mathe.BinTest(tcBin,tiBit)
LOCAL loMathe loMathe = My.Functions.Mathe WAIT WINDOW loMathe.BinTest(CHR(10),3) && Shows .T.
Rückgabe: [Char], BITXOR() zweier CHAR Binärwerte
Char = My.Functions.Mathe.BinXOr(tcBin1 AS STRING, tcBin2 AS STRING) Char = My.Functions.Mathe.BinXOr(tcBin1,tcBin2)
LOCAL loMathe loMathe = My.Functions.Mathe WAIT WINDOW ASC(loMathe.BinXOr(CHR(10),CHR(5))) && Shows 15
Rückgabe: [Boolean],Löscht das angegebene BIT in tiZahl und gibt .T. bzw. .F. zurück, ob es geklappt hat. tiZahl wird als Reference übergeben
Boolean = My.Functions.Mathe.BitClear(tiZahl AS INTEGER @, tiBit AS INTEGER) Boolean = My.Functions.Mathe.BitClear(@tiZahl,tiBit)
LOCAL loMathe , liZahl AS Integer loMathe = My.Functions.Mathe liZahl = 10 WAIT WINDOW loMathe.BitClear(@liZahl,3) && Shows .T. WAIT WINDOW m.liZahl && Shows 2
Rückgabe: [Boolean], Vergleicht den Integer tiBit mit tiComp mittels BitAnd() und gibt .T. bzw. .F. zurück
Boolean = My.Functions.Mathe.BitComp(tiBit AS Integer,tiComp AS Integer) Boolean = My.Functions.Mathe.BitComp(tiBit,tiComp)
LOCAL loMathe loMathe = My.Functions.Mathe WAIT WINDOW loMathe.BitComp(10,15) && Shows .F.
Rückgabe: [Boolean], Setzt das angegebene BIT in tiZahl und gibt .T. bzw. .F. zurück, ob es geklappt hat. tiZahl wird als Reference übergeben
Boolean = My.Functions.Mathe.BitSet(tiZahl AS INTEGER @, tiBit AS INTEGER) Boolean = My.Functions.Mathe.BitSet(@tiZahl,tiBit)
LOCAL loMathe , liZahl AS Integer loMathe = My.Functions.Mathe liZahl = 10 WAIT WINDOW loMathe.BitSet(@liZahl,0) && Shows .T. WAIT WINDOW m.liZahl && Shows 11
Rückgabe:[Character], Gibtr das Higherbyte einer Zahl (Integer) zurück. tiZahl = 0 - 65535
Character = My.Functions.Mathe.ByteHigh(tiZahl AS INTEGER) Character = My.Functions.Mathe.ByteHigh(tiZahl)
LOCAL loMathe loMathe = My.Functions.Mathe WAIT WINDOW ASC(loMathe.Bytehigh(1023)) && Shows 3
Rückgabe:[Character], Gibtr das Lowerbyte einer Zahl (Integer) zurück. tiZahl = 0 - 65535
Character = My.Functions.Mathe.ByteLow(tiZahl AS INTEGER) Character = My.Functions.Mathe.ByteLow(tiZahl)
LOCAL loMathe loMathe = My.Functions.Mathe WAIT WINDOW ASC(loMathe.ByteLow(1023)) && Shows 255
Rückgabe:[String], Gibtr das Lower und Higherbyte einer Zahl (Integer) zurück. tiZahl = 0 - 65535. Rückgabe : LowByte/HighByte
String = My.Functions.Mathe.ByteWord(tiZahl AS INTEGER,tlHightByteLowByte AS Boolean) String = My.Functions.Mathe.ByteWord(tiZahl,tlHightByteLowByte)
LOCAL loMathe loMathe = My.Functions.Mathe WAIT WINDOW loMathe.ByteWord(256*64+65,.F.) && Shows 'A@' L/H WAIT WINDOW loMathe.ByteWord(256*64+65,.T.) && Shows '@A' H/L
Rückgabe: [String], Dreht die zeichenkette um aus 1100 wird 0011 oder aus 1010 with 0101
String = My.Functions.Mathe.CharTurn(tcChars AS STRING) String = My.Functions.Mathe.CharTurn(tcChars)
LOCAL loMathe loMathe = My.Functions.Mathe WAIT WINDOW loMathe.CharTurn('1110') && Shows '0111' WAIT WINDOW loMathe.CharTurn('ABCD') && Shows 'DCBA'
Rückgabe: [String], Wandelt einen Dezimalwert in einen Binärwert um, Parameter 2: tlHightByteLowByte: .f.=Intel
String = My.Functions.Mathe.Dec2Bin(tvDec AS Variant, tiLen AS INTEGER, tlHightByteLowByte AS Boolean) String = My.Functions.Mathe.Dec2Bin(tvDec,tiLen,tlHightByteLowByte)
SyncSafe: Bit7 ist immer 0 aus 32 Bit werden effektiv 28
Variant = My.Functions.Mathe.Dec2BinSS(tnDec AS NUMBER , tiAnz AS INTEGER) Variant = My.Functions.Mathe.Dec2BinSS(tnDec,tiAnz)
Rückgabe: [String], Dezimal nach Dual wandeln, Parameter tndec, tnlen
String = My.Functions.Mathe.Dec2Dual(tnDec AS NUMBER , tiLen AS INTEGER) String = My.Functions.Mathe.Dec2Dual(tnDec,tiLen)
Rückgabe: [String], Dezimal nach Hex wandeln, Parameter tndec, tnlen
String = My.Functions.Mathe.Dec2Hex(tnDec AS NUMBER , tilen AS INTEGER) String = My.Functions.Mathe.Dec2Hex(tnDec,tilen)
Wandelt eine Dezimalzahl in eine Syncsafe Dezimalzahl um (für MP3-Tag)
Variant = My.Functions.Mathe.Dec2SyncSafe(tnDec AS NUMBER , tiLen AS INTEGER) Variant = My.Functions.Mathe.Dec2SyncSafe(tnDec,tiLen)
Rückgabe: [Integer], BITAND() zweier Dezimalzahlen
Integer = My.Functions.Mathe.DecAnd(tiDec1 AS INTEGER, tiDec2 AS INTEGER) Integer = My.Functions.Mathe.DecAnd(tiDec1,tiDec2)
Rückgabe: [Integer], BITOR() zweier Dezimalzahlen
Integer = My.Functions.Mathe.DecOr(tiDec1 AS INTEGER, tiDec2 AS INTEGER) Integer = My.Functions.Mathe.DecOr(tiDec1,tiDec2)
Rückgabe: [Integer], BITXOR() zweier Dezimalzahlen
Integer = My.Functions.Mathe.DecXOr(tiDec1 AS INTEGER, tiDec2 AS INTEGER) Integer = My.Functions.Mathe.DecXOr(tiDec1,tiDec2)
Rückgabe: [Variant], Wandelt einen Digit Ausdruck in einen Binärwert um. Der Digitausdruck kann Integer bzw. String sein... Umkehrfunktion zu Bin2Digit()
Variant = My.Functions.Mathe.Digit2Bin(tvDigit AS Variant, tlHightByteLowByte AS Boolean, tiLen AS INTEGER) Variant = My.Functions.Mathe.Digit2Bin(tvDigit,tlHightByteLowByte,tiLen)
Rückgabe: [Variant], Umwandlung einer cDigitzahl in eine cHexZahl. Umkehrfunktion von Hex2Digit()
Variant = My.Functions.Mathe.Digit2Hex(tcDecZahl AS STRING,tiDecLen AS INTEGER,tiHexLen AS INTEGER) Variant = My.Functions.Mathe.Digit2Hex(tcDecZahl,tiDecLen,tiHexLen)
Rückgabe: [String], Wandelt eine Dualzahl in einen Binärwert um
String = My.Functions.Mathe.Dual2Bin(tcDual AS STRING , tiLen AS INTEGER) String = My.Functions.Mathe.Dual2Bin(tcDual,tiLen)
Rückgabe: [Number], Dual nach Dezimal wandeln, Parameter tcdual
Number = My.Functions.Mathe.Dual2Dec(tcZahl AS STRING) Number = My.Functions.Mathe.Dual2Dec(tcZahl)
Rückgabe: [String], Dual nach Hexadezimal wandeln, Parameter tcdual, tnlenhex
String = My.Functions.Mathe.Dual2Hex(tcZahl AS STRING, tiLen AS INTEGER) String = My.Functions.Mathe.Dual2Hex(tcZahl,tiLen)
Rückgabe: [String], BITAND() zweier cDualzahlen.
String = My.Functions.Mathe.DualAnd(tcDual1 AS STRING, tcDual2 AS STRING) String = My.Functions.Mathe.DualAnd(tcDual1,tcDual2)
Rückgabe: [String], BITCLEAR() eines cDualwertes
String = My.Functions.Mathe.DualClear(tcDual AS STRING, tiBit AS INTEGER) String = My.Functions.Mathe.DualClear(tcDual,tiBit)
Rückgabe: [String], BITLSHIFT() eines cDualwertes
String = My.Functions.Mathe.DualLShift(tcDual AS STRING, tiBits AS INTEGER) String = My.Functions.Mathe.DualLShift(tcDual,tiBits)
Rückgabe: [String], BITNOT() eines cDualwertes
String = My.Functions.Mathe.DualNot(tcDual AS STRING) String = My.Functions.Mathe.DualNot(tcDual)
Rückgabe: [String], BITOR() zweier cDualzahlen
String = My.Functions.Mathe.DualOr(tcDual1 AS STRING, tcDual2 AS STRING) String = My.Functions.Mathe.DualOr(tcDual1,tcDual2)
Rückgabe: [String], BITRSHIFT() eines cDualwertes
String = My.Functions.Mathe.DualRShift(tcDual AS STRING, tiBits AS INTEGER) String = My.Functions.Mathe.DualRShift(tcDual,tiBits)
Rückgabe: [String], BITSET() eines cDualwertes
String = My.Functions.Mathe.DualSet(tcDual AS STRING, tiBit AS INTEGER) String = My.Functions.Mathe.DualSet(tcDual,tiBit)
Rückgabe: [Boolean], BITTEST() eines cDualwertes
Boolean = My.Functions.Mathe.DualTest(tcDual AS STRING, tiBit AS INTEGER) Boolean = My.Functions.Mathe.DualTest(tcDual,tiBit)
Rückgabe:[Integer], Umwandlung einer Dualzahl "010011100.." in einen numerischen Wert unter Berücksichtigung das der Wert für "1" auch anders sein kann. Beispiel: "NNJJJJNJJ.." wobei "J" als "1" interpretiert wird.
Integer = My.Functions.Mathe.DualToNum(tcDual AS STRING,tcHighValue AS STRING) Integer = My.Functions.Mathe.DualToNum(tcDual,tcHighValue)
Rückgabe: [String], BITXOR() zweier cDualzahlen
String = My.Functions.Mathe.DualXOr(tcDual1 AS STRING, tcDual2 AS STRING) String = My.Functions.Mathe.DualXOr(tcDual1,tcDual2)
Ausführen eines VFP-Befehls mit EVALUATE().
Achtung! Eventuell müssen Variablen als PRIVATE deklariert werden!ENDTEXT
*
TEXT TO lcMessage NOSHOW TEXTMERGE
Ausführen eines VFP-Befehls mit EVALUATE().
Variant = My.Functions.Mathe.Evaluate(pcExpression AS STRING,pvDefault AS Variant,tvP1 AS Variant,tvP2 AS Variant,tvP3 AS Variant,tvP4 AS Variant, tvP5 AS Variant,tvP6 AS Variant,tvP7 AS Variant,tvP8 AS Variant,tvP9 AS Variant) Variant = My.Functions.Mathe.Evaluate(pcExpression,pvDefault,tvP1,tvP2,tvP3,tvP4,tvP5,tvP6,tvP7,tvP8,tvP9)
*/ Mit Evaluate kann eine Befehlszeile ausgeführt werden */ Eventuell benutzte Variablen sind PRIVATE zu deklarieren PRIVATE pnVar1 AS Number , pnVar2 AS Number LOCAL lnVar AS Number STORE 2 TO pnVar1,pnVar2 lnVar = My.Functions.Mathe.Evaluate([m.pnVar1+m.pnVar2]) WAIT WINDOW m.lnVar && Ergibt 4... ENDTEXT
Ausführen eines VFP-Scripts incl. der Prüfung, ob ein ALIAS besteht.
Variant = My.Functions.Mathe.ExecScript(_es_pcAlias AS STRING,_es_pcScript AS STRING,_es_tlBoolean AS Boolean, _es_tvP1 AS Variant,_es_tvP2 AS Variant,_es_tvP3 AS Variant,_es_tvP4 AS Variant,_es_tvP5 AS Variant,_es_tvP6 AS Variant, _es_tvP7 AS Variant,_es_tvP8 AS Variant,_es_tvP9 AS V) Variant = My.Functions.Mathe.ExecScript(_es_pcAlias,_es_pcScript,_es_tlBoolean,_es_tvP1,_es_tvP2,_es_tvP3,_es_tvP4,_es_tvP5,_es_tvP6,_es_tvP7,_es_tvP8,_es_tvP9)
*/ Mit EXECSCRIPT kann ein VFP-Script ausgeführt werden LOCAL lcScript AS String,lnVar1 AS Number,lnVar2 AS Number,lnVar AS Number TEXT TO lcScript NOSHOW TEXTMERGE LPARAMETERS tnVar1 AS Number @,tnVar2 AS Number @ tnVar1 = m.tnVar1 + 1 tnVar2 = m.tnVar2 - 2 RETURN m.tnVar1 + m.tnVar2 ENDTEXT */ Vorbelegen der Variablen (Parameter) STORE 2 TO lnVar1,lnVar2 lnVar = My.Functions.Mathe.ExecScript("",m.lcScript,0,@lnVar1,@lnVar2) */ und das Ergebnis... WAIT WINDOW m.lnVar WAIT WINDOW m.lnVar1 WAIT WINDOW m.lnVar2
Ausführen eines VFP-Scripts incl. PARAMETER (Collection)
Als Parameter wird eine Collection mit Informationen übergeben!
Variant = My.Functions.Mathe.ExecScriptP(tcScript AS STRING,toPara AS COLLECTION) Variant = My.Functions.Mathe.ExecScriptP(tcScript,toPara)
*/ Mit EXECSCRIPTP kann ein VFP-Script ausgeführt werden LOCAL lcScript AS String,lnVar AS Number,loColl AS Collection loColl = CREATEOBJECT("Collection") loColl.Add(2,"Var1") loColl.Add(2,"Var2") TEXT TO lcScript NOSHOW TEXTMERGE LPARAMETERS toColl AS Collection RETURN toColl.Item("Var1") + toColl.Item("Var2") ENDTEXT lnVar = My.Functions.Mathe.ExecScriptP(m.lcScript,m.loColl) */ und das Ergebnis... WAIT WINDOW m.lnVar
Rückgabe:[Number], Gibt die Anzahl der Nachkommastellen einer Zahl zurück. Rückgabe kann zwischen 0 und 99 liegen.
Number = My.Functions.Mathe.GetNachKomma(tnZahl AS Number) Number = My.Functions.Mathe.GetNachKomma(tnZahl)
Wandelt übergebene Parameter in eine Collection um.
Umkehrfunktion zu SetParameters.
Variant = My.Functions.Mathe.GetParameters(tvP1 AS Variant,tvP2 AS Variant,tvP3 AS Variant,tvP4 AS Variant,tvP5 AS Variant,tvP6 AS Variant,tvP7 AS Variant,tvP8 AS Variant,tvP9 AS Variant) Variant = My.Functions.Mathe.GetParameters(tvP1,tvP2,tvP3,tvP4,tvP5,tvP6,tvP7,tvP8,tvP9)
*/ Hier können mehrere Parameter in eine Collection übertragen werden LOCAL loCollection AS Collection , lni AS Integer , lcNames AS String loCollection = My.Functions.Mathe.GetParameters(1,DATE(),TIME()) WAIT WINDOW m.loCollection.Count && Anzahl der Werte (3) */ Die Namen der Parameter bestimmen lcNames = "" FOR m.lni = 1 TO m.loCollection.Count lcNames = m.lcNames + ";" + m.loCollection.GetKey(m.lni) NEXT m.lni WAIT WINDOW SUBSTR(m.lcNames,2)
Wandelt übergebene Parameter in eine Collection um.
Jedoch wird als 'erster' Parameter die Anzahl der Parameter mitgegeben.
Variant = My.Functions.Mathe.GetParametersCount(tnCnt AS Number,tvP1 AS Variant,tvP2 AS Variant,tvP3 AS Variant,tvP4 AS Variant,tvP5 AS Variant,tvP6 AS Variant,tvP7 AS Variant,tvP8 AS Variant,tvP9 AS Variant) Variant = My.Functions.Mathe.GetParametersCount(tnCnt,tvP1,tvP2,tvP3,tvP4,tvP5,tvP6,tvP7,tvP8,tvP9)
*/ Hier können mehrere Parameter in eine Collection übertragen werden */ Als Beispiel kann nur der Aufruf eines Scripts / einer Methode dienen LPARAMETERS tp1 AS Variant , tp2 AS Variant , tp3 AS Variant && Es könnten mehr sein! LOCAL loCollection AS Collection , lni AS Integer lni = PCOUNT() && Wieviele Parameter wurden übergeben? loCollection = My.Functions.Mathe.GetParametersCount(m.lni,m.tp1,m.tp2,m.tp3) WAIT WINDOW m.loCollection.Count && Anzahl der Werte (?)
Rückgabe: [String], Wandelt eine Hexadezimale Zahl in einen Binärwert um
String = My.Functions.Mathe.Hex2Bin(tcHex AS STRING , tiLen AS INTEGER , tlHightByteLowByte AS Boolean) String = My.Functions.Mathe.Hex2Bin(tcHex,tiLen,tlHightByteLowByte)
Syncsafe
Variant = My.Functions.Mathe.Hex2BinSS(tcHex AS STRING ,tiLen AS INTEGER) Variant = My.Functions.Mathe.Hex2BinSS(tcHex,tiLen)
Rückgabe: [Number], Hexdezimal nach Dezimal wandeln, Parameter tchex
Number = My.Functions.Mathe.Hex2Dec(tcZahl AS STRING) Number = My.Functions.Mathe.Hex2Dec(tcZahl)
Rückgabe: [Variant], Wandelt eine cHexadezimalzahl in dezimale Digits um. Rückgabe normalerweise (String) bei Fehler .NULL.
Variant = My.Functions.Mathe.Hex2Digit(tcHexZahl AS String, tiHexLen AS Integer, tiDecLen AS Integer) Variant = My.Functions.Mathe.Hex2Digit(tcHexZahl,tiHexLen,tiDecLen)
Rückgabe: [String], Hexadezimal nach Dual wandeln, Parameter tchex, tnlendual
String = My.Functions.Mathe.Hex2Dual(tcZahl AS STRING , tiLen AS INTEGER) String = My.Functions.Mathe.Hex2Dual(tcZahl,tiLen)
Rückgabe: [Number], Wandelt einen Zeichenwert, der als Hexadezimale Zahl interpretiert werden kann in eine numerischen Wert um
Number = My.Functions.Mathe.Hex2Num(tcZahl AS STRING) Number = My.Functions.Mathe.Hex2Num(tcZahl)
Rückgabe: [String], BITAND() zweier cHexzahlen
String = My.Functions.Mathe.HexAnd(tcHex1 AS STRING, tcHex2 AS STRING) String = My.Functions.Mathe.HexAnd(tcHex1,tcHex2)
Rückgabe: [String], BITCLEAR() eines cHexwertes
String = My.Functions.Mathe.HexClear(tcHex AS STRING, tiBit AS INTEGER) String = My.Functions.Mathe.HexClear(tcHex,tiBit)
Rückgabe: [String], BITLSHIFT() eines cHexwertes
String = My.Functions.Mathe.HexLShift(tcHex AS STRING, tiBits AS INTEGER) String = My.Functions.Mathe.HexLShift(tcHex,tiBits)
Rückgabe: [String], BITNOT() eines cHexwertes
String = My.Functions.Mathe.HexNot(tcHex AS STRING) String = My.Functions.Mathe.HexNot(tcHex)
Rückgabe: [String], BITOR() zweier cHexzahlen
String = My.Functions.Mathe.HexOr(tcHex1 AS STRING, tcHex2 AS STRING) String = My.Functions.Mathe.HexOr(tcHex1,tcHex2)
Rückgabe: [String], BITRSHIFT() eines cHexwertes
String = My.Functions.Mathe.HexRShift(tcHex AS STRING, tiBits AS INTEGER) String = My.Functions.Mathe.HexRShift(tcHex,tiBits)
Rückgabe: [String], BITSET() eines cHexwertes
String = My.Functions.Mathe.HexSet(tcHex AS STRING, tiBit AS INTEGER) String = My.Functions.Mathe.HexSet(tcHex,tiBit)
Rückgabe: [Boolean], BITTEST() eines cHexwertes
Boolean = My.Functions.Mathe.HexTest(tcHex AS STRING, tiBit AS INTEGER) Boolean = My.Functions.Mathe.HexTest(tcHex,tiBit)
Rückgabe: [String], BITXOR() zweier cHexzahlen
String = My.Functions.Mathe.HexXOr(tcHex1 AS STRING, tcHex2 AS STRING) String = My.Functions.Mathe.HexXOr(tcHex1,tcHex2)
String = My.Functions.Mathe.IBanDE(tcBLZ AS String,tcKTO AS String) String = My.Functions.Mathe.IBanDE(tcBLZ,tcKTO)
String = My.Functions.Mathe.IntToRoemisch(tiZahl AS INTEGER) String = My.Functions.Mathe.IntToRoemisch(tiZahl)
Rückgabe:[Boolean], Prüft einen String auf numerische Werte. Gibt .T. zurück, wenn der String in eine Zahl umgewandelt werden kann.
Boolean = My.Functions.Mathe.IsNumerisch(tcString AS STRING) Boolean = My.Functions.Mathe.IsNumerisch(tcString)
Gibt an, ob eine Zahl im Syncsafeformat sein könnte
Variant = My.Functions.Mathe.IsSyncSafe(tnSync AS NUMBER , tiLen AS INTEGER) Variant = My.Functions.Mathe.IsSyncSafe(tnSync,tiLen)
Rückgabe:[String], Filtert numerische Zeichen aus einem String und gibt diese zurück. Beispiel: "AB0123 GH 456 XZ 789" => "0123456789"
String = My.Functions.Mathe.JustDigit(tcString AS STRING) String = My.Functions.Mathe.JustDigit(tcString)
Rückgabe:[Number], Berechnet den Logarithmus einer Zahl aus Basis von X. LOG10(Zahl) - Basis=10, LOG(Zahl) - Basis=e, LOGx(Zahl,Basis)
Number = My.Functions.Mathe.LOGx(tnZahl AS NUMBER,tnBasis AS NUMBER) Number = My.Functions.Mathe.LOGx(tnZahl,tnBasis)
Rückgabe:[Integer], Logische Funktionen zweier Zahlen (INT). tcLogic $ "AND,OR,NAND,NOR,XOR,NXOR".
Integer = My.Functions.Mathe.Logic(tcLogic AS STRING,tiZahl1 AS INTEGER,tiZahl2 AS INTEGER) Integer = My.Functions.Mathe.Logic(tcLogic,tiZahl1,tiZahl2)
Rückgabe: [String], Umwandeln eines num. Ausdrucks in einen Binärwert
String = My.Functions.Mathe.Num2Bin(tnZahl AS NUMBER ,tnLength AS NUMBER) String = My.Functions.Mathe.Num2Bin(tnZahl,tnLength)
Rückgabe:[String], Wandelt eine Zahl in eine Duale Zeichenfolge um. 13 => "1101". tiLen = Länge der Rückgabe
String = My.Functions.Mathe.Num2Dual(tnZahl AS NUMBER,tiLen AS INTEGER) String = My.Functions.Mathe.Num2Dual(tnZahl,tiLen)
Rückgabe: [String], Konvertiert eine numerischen Wert in eine Hexadezimale Zahl
String = My.Functions.Mathe.Num2Hex(tnZahl AS NUMBER ,tnByte AS NUMBER) String = My.Functions.Mathe.Num2Hex(tnZahl,tnByte)
Rückgabe:[String], Wandelt eine Zahl in eine Duale Zeichenfolge um. 13 => "1101". tiLen = Länge der Rückgabe. tcLow und tcHigh sind die Zeichen für "0" bzw. "1"
String = My.Functions.Mathe.NumToDual(tnZahl AS NUMBER,tiLen AS INTEGER,tcHigh AS STRING,tcLow AS STRING) String = My.Functions.Mathe.NumToDual(tnZahl,tiLen,tcHigh,tcLow)
Variant = My.Functions.Mathe.PrintDual4Bin(tcBin AS STRING , tlNoPrint AS Boolean , tlHbLb AS Boolean) Variant = My.Functions.Mathe.PrintDual4Bin(tcBin,tlNoPrint,tlHbLb)
Druckt Hexzahlen für Binärwerte aus
Variant = My.Functions.Mathe.PrintHex4Bin(tcBin AS STRING, tlNoPrint AS Boolean , tlHbLb AS Boolean) Variant = My.Functions.Mathe.PrintHex4Bin(tcBin,tlNoPrint,tlHbLb)
Rückgabe:[Number], Erzeugt eine Zufallszahl zwischen den Grenzen von tnMin und tnMax mit der Anzahl der Nachkommastellen tnKomma. tnKomma=0 wenn nicht angegeben
Number = My.Functions.Mathe.Random(tnMin AS NUMBER,tnMax AS NUMBER,tnKomma AS INTEGER) Number = My.Functions.Mathe.Random(tnMin,tnMax,tnKomma)
Integer = My.Functions.Mathe.RoemischToInt(tcRoemisch AS STRING) Integer = My.Functions.Mathe.RoemischToInt(tcRoemisch)
Rückgabe:[Number], Umrechnung der Währung, geht mit verschiedenen Übergabewerten
Number = My.Functions.Mathe.RoleC(tcIdc03 AS STRING,tnCF AS NUMBER,tnCQ AS NUMBER) Number = My.Functions.Mathe.RoleC(tcIdc03,tnCF,tnCQ)
Rückgabe:[Number], Berechnen eines prozentualen Auf- bzw. Abschlags. Regeln: "%,\,.,F
Number = My.Functions.Mathe.RoleP(tcR AS String,tnP AS Number,tnS AS Number,tnE AS Number) Number = My.Functions.Mathe.RoleP(tcR,tnP,tnS,tnE)
Rückgabe:[Number], Umrechnung der Quantity
Number = My.Functions.Mathe.RoleQ(tcR AS String,tnF AS Number,tnS AS Number) Number = My.Functions.Mathe.RoleQ(tcR,tnF,tnS)
Rückgabe:[Number], Berechnen eines Preises YxQn nach YxQm mit Regel und Faktor. Wie RoleQ jedoch wird der Faktor bei der Berechnung gedreht...
Number = My.Functions.Mathe.RoleY(tcR AS String,tnF AS Number,tnS AS Number) Number = My.Functions.Mathe.RoleY(tcR,tnF,tnS)
Wandelt eine übergebene Collection in Parameter um.
Umkehrfunktion zu GetParameters.
Variant = My.Functions.Mathe.SetParameters(toPara AS Collection,tvP1 AS Variant @,tvP2 AS Variant @,tvP3 AS Variant @,tvP4 AS Variant @,tvP5 AS Variant @,tvP6 AS Variant @,tvP7 AS Variant @,tvP8 AS Variant @,tvP9 AS Variant @) Variant = My.Functions.Mathe.SetParameters(toPara,@tvP1,@tvP2,@tvP3,@tvP4,@tvP5,@tvP6,@tvP7,@tvP8,@tvP9)
*/ Umwandeln einer Collection in Parameter LOCAL loCollection AS Collection,lnVar1 AS Number,lnVar2 AS Number loCollection = CREATEOBJECT("Collection") =loCollection.Add(1,"tvp1") =loCollection.Add(2,"tvp2") =My.Functions.Mathe.SetParameters(m.loCollection,@lnVar1,@lnVar2) WAIT WINDOW m.lnVar1 WAIT WINDOW m.lnVar2
Wandelt eine Syncsafe Dezimalzahl in eine Dezimalzahl um (für MP3-Tag)
Variant = My.Functions.Mathe.SyncSafe2Dec(tnSync AS NUMBER, tnLen AS NUMBER) Variant = My.Functions.Mathe.SyncSafe2Dec(tnSync,tnLen)
Number = My.Functions.Mathe.TwoPc2OnePc(tnP1 AS NUMBER , tnP2 AS NUMBER , tlAdditive AS Boolean) Number = My.Functions.Mathe.TwoPc2OnePc(tnP1,tnP2,tlAdditive)
Anzahl der Datensätze eines SQL Statements ermitteln.
Die Rückgabe ist Number oder .NULL.
Die Datenbankangaben:
CSYSDIR! => My.Clients.Path.cSysDir
CDBFDIR! => My.Clients.Path.cDbfDir
CFRXDIR! => My.Clients.Path.cFrxDir
CNETDIR! => My.Clients.Path.cNetDir
CTMPDIR! => My.Clients.Path.cTmpDir
werden unter VFP-Tabellen in den entsprechenden Pfad umgewandelt!
Bei der Verwendung eines SQL-Servers werden diese Informationen gegen den Datenbanknamen im SQL-Server ausgetauscht.
Variant = My.Functions.Mathe._SqlCount(tcSql AS String) Variant = My.Functions.Mathe._SqlCount(tcSql)
LOCAL lcSql AS String lcSql = [SELECT COUNT(*) FROM CSYSDIR!Y01 WHERE idc26="DE " AND ipy01="SU"] IF My.Functions.Mathe._SqlCount(m.lcSql)>0 WAIT WINDOW "Es sind Daten vorhanden!" ENDIF */ Bemerkung: */ Bei der Angabe der Datenbank, hier CSYSDIR!, wird der Wert gegen den Pfad ausgetauscht!
Werden Datensätze im SQL-Statement ermittelt?
Die Rückgabe ist Boolean oder .NULL.
Die Datenbankangaben:
CSYSDIR! => My.Clients.Path.cSysDir
CDBFDIR! => My.Clients.Path.cDbfDir
CFRXDIR! => My.Clients.Path.cFrxDir
CNETDIR! => My.Clients.Path.cNetDir
CTMPDIR! => My.Clients.Path.cTmpDir
werden unter VFP-Tabellen in den entsprechenden Pfad umgewandelt!
Bei der Verwendung eines SQL-Servers werden diese Informationen gegen den Datenbanknamen im SQL-Server ausgetauscht.
Variant = My.Functions.Mathe._SqlExist(tcSql AS String) Variant = My.Functions.Mathe._SqlExist(tcSql)
LOCAL lcSql AS String lcSql = [SELECT ipy01 FROM CSYSDIR!Y01 WHERE idc26="DE " AND ipy01="SU"] IF My.Functions.Mathe._SqlExist(m.lcSql) && Gibt Boolean zurück WAIT WINDOW "Es sind Daten vorhanden!" ENDIF */ Bemerkung: */ Bei der Angabe der Datenbank, hier CSYSDIR!, wird der Wert gegen den Pfad ausgetauscht!
Ausführen eines SQL-Statements und Rückgabe des angegebenen Cursors.
Die Rückgabe ist Boolean oder .NULL.
Die Datenbankangaben:
CSYSDIR! => My.Clients.Path.cSysDir
CDBFDIR! => My.Clients.Path.cDbfDir
CFRXDIR! => My.Clients.Path.cFrxDir
CNETDIR! => My.Clients.Path.cNetDir
CTMPDIR! => My.Clients.Path.cTmpDir
werden unter VFP-Tabellen in den entsprechenden Pfad umgewandelt!
Bei der Verwendung eines SQL-Servers werden diese Informationen gegen den Datenbanknamen im SQL-Server ausgetauscht.
Variant = My.Functions.Mathe._SqlRead(tcSql AS String,tcAlias AS String,tvTable AS Variant,tcIndex AS String) Variant = My.Functions.Mathe._SqlRead(tcSql,tcAlias,tvTable,tcIndex)
LOCAL lcSql AS String lcSql = [SELECT * FROM CSYSDIR!Y01 WHERE idc26="DE " AND ipy01="SU"] IF My.Functions.Mathe._SqlRead(m.lcSql,"qY01",2) && Gibt Boolean zurück ACTIVATE _SCREEN BROWSE ENDIF */ Bemerkung: */ Bei der Angabe der Datenbank, hier CSYSDIR!, wird der Wert gegen den Pfad ausgetauscht! */ Die einzelnen Parameter: */ tcSql AS String,tcAlias AS String,tvTable AS Variant,tcIndex AS String */ Ein muss sind: tcSql AS String,tcAlias AS String */ tvTable kann angegeben werden mit: */ .F. => Cursor incl. __Changed [L] und __New [L], .T. - Tabelle incl. */ Bit-0 => 1 - Als Tabelle, 0 - Als Cursor */ Bit-1 => 1 - Ohne __Changed und __New, 0 - Mit... */ tcIndex kann angegeben werden, wenn Indizes auf dem Cursor / der Tabelle benötigt werden. */ "IndexKey1#IndexTag1;IndexKey2#IndexTag2;...." */ Wird kein IndexTag angegeben und der IndexKey NICHT aus einer Funktion ermittelt, so hat der IndexKey den Namen des IndexTag! */ Wird der IndexKey aus einer Funktion gebildet und es ist kein IndexTag angegeben, so erhält der IndexTag den Namen _Index<Nummer>
Ausführen eines SQL-Statements in ein Array und Rückgabe ob Daten ermittelt wurden.
Die Rückgabe ist Boolean oder .NULL.
Die Datenbankangaben:
CSYSDIR! => My.Clients.Path.cSysDir
CDBFDIR! => My.Clients.Path.cDbfDir
CFRXDIR! => My.Clients.Path.cFrxDir
CNETDIR! => My.Clients.Path.cNetDir
CTMPDIR! => My.Clients.Path.cTmpDir
werden unter VFP-Tabellen in den entsprechenden Pfad umgewandelt!
Bei der Verwendung eines SQL-Servers werden diese Informationen gegen den Datenbanknamen im SQL-Server ausgetauscht.
Variant = My.Functions.Mathe._SqlReadArray(tcSql AS String,toObject AS Object,taArray) Variant = My.Functions.Mathe._SqlReadArray(tcSql,toObject,taArray)
LOCAL lcSql AS String , laErg[1] , loObject AS Object lcSql = [SELECT * FROM CSYSDIR!Y01 WHERE idc26="DE " AND ipy01="SU"] */ Ausführen in ein lokales Array IF My.Functions.Mathe._SqlReadArray(m.lcSql,.NULL.,@laErg) && Es gibt Datensätze... */ FOR i = ... NEXT i ENDIF */ Ausführen in ein Objekt-Array loObject = CREATEOBJECT("EMPTY") =ADDPROPERTY(loObject,"aErg[1]") IF My.Functions.Mathe._SqlReadArray(m.lcSql,m.loObject,"aErg") && Es gibt Datensätze... */ FOR i = ... NEXT i ENDIF
Ausführen eines SQL-Statements in eine Collection und Rückgabe der Collection.
Die Rückgabe ist Collection oder .NULL.
Die Datenbankangaben:
CSYSDIR! => My.Clients.Path.cSysDir
CDBFDIR! => My.Clients.Path.cDbfDir
CFRXDIR! => My.Clients.Path.cFrxDir
CNETDIR! => My.Clients.Path.cNetDir
CTMPDIR! => My.Clients.Path.cTmpDir
werden unter VFP-Tabellen in den entsprechenden Pfad umgewandelt!
Bei der Verwendung eines SQL-Servers werden diese Informationen gegen den Datenbanknamen im SQL-Server ausgetauscht.
Variant = My.Functions.Mathe._SqlReadCollection(tcSql AS String,tcIndex AS String) Variant = My.Functions.Mathe._SqlReadCollection(tcSql,tcIndex)
LOCAL lcSql AS String , loColl AS Collection lcSql = [SELECT * FROM CSYSDIR!Y01 WHERE idc26="DE " AND ipy01="SU"] */ Normale Ausführung OHNE Indexangabe. */ Die Keys der Collection sind fortlaufend nummeriert! loColl= My.Functions.Mathe._SqlReadCollection(m.lcSql) WAIT WINDOW loColl.GetKey(1) && "0000001" */ Hat der SQL einen eindeutigen Key so kann dieser benutzt werden! loColl= My.Functions.Mathe._SqlReadCollection(m.lcSql,"ipy01") WAIT WINDOW loColl.GetKey(1) && "SU0"
Ausführen eines SQL-Statements und Rückgabe der Value des ERSTEN Feldes.
Die Rückgabe ist Variant oder .NULL.
Die Datenbankangaben:
CSYSDIR! => My.Clients.Path.cSysDir
CDBFDIR! => My.Clients.Path.cDbfDir
CFRXDIR! => My.Clients.Path.cFrxDir
CNETDIR! => My.Clients.Path.cNetDir
CTMPDIR! => My.Clients.Path.cTmpDir
werden unter VFP-Tabellen in den entsprechenden Pfad umgewandelt!
Bei der Verwendung eines SQL-Servers werden diese Informationen gegen den Datenbanknamen im SQL-Server ausgetauscht.
Variant = My.Functions.Mathe._SqlReadValue(tcSql AS String,tiValue AS Integer) Variant = My.Functions.Mathe._SqlReadValue(tcSql,tiValue)
LOCAL lcSql AS String , lvValue AS Variant */ Gibt den Inhalt der ERSTEN Spalte zurück lcSql = [SELECT bezei,kurz,master FROM CSYSDIR!Y01 WHERE idc26="DE " AND ipy01="SU"] lvValue = My.Functions.Mathe._SqlReadValue(m.lcSql) && y01.Bezei */ Gibt den Inhalt der ZWEITEN Spalte zurück lcSql = [SELECT bezei,kurz,master FROM CSYSDIR!Y01 WHERE idc26="DE " AND ipy01="SU"] lvValue = My.Functions.Mathe._SqlReadValue(m.lcSql,2) && y01.Kurz
UPDATE eines lokalen Cursors gegenüber der angegebenen Tabelle durchführen.
Die Rückgabe ist Boolean oder .NULL.
Der Cursor MUSS die Spalten __Changed und __New enthalten!
Außerdem MUSS die Zieltabelle die Spalte LastUpd enthalten!
Variant = My.Functions.Mathe._SqlUpdate(tcTable AS STRING,tcAlias AS STRING,tcIdName AS STRING,tcFilter AS String) Variant = My.Functions.Mathe._SqlUpdate(tcTable,tcAlias,tcIdName,tcFilter)
LOCAL lcSql AS String , tlUpdate AS Boolean lcSql = [SELECT * FROM CDBFDIR!B01 WHERE b01.artnr='SIE.3TH'] */ Lesen der Daten vom Backend IF My.Functions.Mathe._SqlRead(m.lcSql,"qB01",1) */ Ändern der Daten... SELECT qB01 REPLACE ALL match WITH "LEISTUNGSSCHALTER",__Changed WITH .T. tlUpdate = My.Functions.Mathe._SqlUpdate("B01",ALIAS(),"IDB01") IF NOT m.tlUpdate WAIT WINDOW My.Functions.Mathe.cLastError ENDIF ENDIF
UPDATE mehrerer lokaler Cursor gegenüber den angegebenen Tabellen durchführen.
Die Rückgabe ist Boolean oder .NULL.
Die Cursor MUSS die Spalten __Changed und __New enthalten!
Außerdem MUSS die Zieltabelle die Spalte LastUpd enthalten!
;Filter1 = My.Functions.Mathe._SqlUpdateAll(tcList AS STRING) ;Filter1 = My.Functions.Mathe._SqlUpdateAll(tcList)
LOCAL tlUpdate AS Boolean */ Lesen der Daten vom Backend IF My.Functions.Mathe._SqlRead([SELECT * FROM CDBFDIR!B01 WHERE b01.artnr='SIE.3TH'],"qB01",1) AND ; My.Functions.Mathe._SqlRead([SELECT d03.* FROM CDBFDIR!D03 INNER JOIN CDBFDIR!B01 ON d03.idd03=b01.idd03 WHERE b01.artnr='SIE.3TH'],"qD03",1) */ Ändern der Daten... UPDATE qB01 SET lang = qD03.bez, __Changed = .T. FROM qD03 WHERE qB01.idd03=qD03.idd03 UPDATE qD03 SET ekpdatum = My.xDate, __Changed = .T. tlUpdate = My.Functions.Mathe._SqlUpdateAll("B01;QB01;IDB01#D03;QD03;IDD03") IF NOT m.tlUpdate WAIT WINDOW My.Functions.Mathe.cLastError ENDIF ENDIF */ Hinweis: */ Der Update der einzel angegebenen Cursor wird mit einer Transaktion durchgeführt! */ Läuft einer der Updates auf einen Fehler wird die Änderung rückgängig gemacht! */ Der String ist folgendermaßen aufgebaut: */ "Tableinfo1#Tableinfo2#Tableinfo3#..." */ Tableinfo: */ Tabelle;Cursor;ID-Field[;Filter]
String = My.Functions.Mathe.cModulo(tcZahl AS String, tvModulo AS Variant) String = My.Functions.Mathe.cModulo(tcZahl,tvModulo)
Rückgabe:[Number], Runden einer Zahl wie mit ROUND() jedoch über den Umweg durch Umwandlung in einen String. Sollte genommen werden, wenn ROUND() zu einem Fehler führt...
Number = My.Functions.Mathe.eRound(tnZahl AS NUMBER,tnNachKomma AS NUMBER) Number = My.Functions.Mathe.eRound(tnZahl,tnNachKomma)
Rückgabe:[Number], Runden einer Währung mit einer best. Anzahl von Nachkommastellen und kleinster Währungseinheit.
Number = My.Functions.Mathe.xRound(tnZahl AS NUMBER,tnMinw AS NUMBER,tnRound AS NUMBER) Number = My.Functions.Mathe.xRound(tnZahl,tnMinw,tnRound)
Z = My.Functions.Mathe.ZahlenSysteme
Mit dieser Property kann der letzte Fehler im Klartext abgerufen werden.
String = My.Functions.Mathe.cLastError
*/ Vorausgesetzt wird, dass My bekannt ist... LOCAL lcError AS String lcError = My.Functions.Mathe.cLastError
Methode in der der letzte Fehler auftrat.
Aufbau: [Fehlernummer] [Methode] [Zeilennummer] [Message]
String = My.Functions.Mathe.cMethod
*/ Abruf... WAIT WINDOW My.Functions.Mathe.cMethod
Number = My.Functions.Mathe.iRoemisch[tcIndex1 AS String | tiIndex1 AS Integer , tiIndex2 AS Integer] Number = My.Functions.Mathe.iRoemisch[tcIndex1|,tiIndex1,tiIndex2]
Thermosanzeige bei der Ausführung
Boolean = My.Functions.Mathe.lShowThermos
My.Functions.Mathe.lShowThermos = .T.
Fehlernummer des letzten Fehlers.
Ist der Wert kleiner null, so handelt es sich um einen logischen Fehler.
Number = My.Functions.Mathe.nError
WAIT WINDOW My.Functions.Mathe.nError
Zeilennummer, in der der letzte Fehler auftrat
Number = My.Functions.Mathe.nLine
WAIT WINDOW My.Functions.Mathe.nLine
Verarbeitete Datensätze
Number = My.Functions.Mathe.nRecords
WAIT WINDOW My.Functions.Mathe.nRecords
Ausführungszeit in Sekunden
Number = My.Functions.Mathe.nSeconds
WAIT WINDOW My.Functions.Mathe.nSeconds
Status der Ausführung
Number = My.Functions.Mathe.nStatus
WAIT WINDOW My.Functions.Mathe.nStatus
Merkt sich die Datenumgebung für eine Verarbeitung.
Beim Release der Variable wird die vorherige Datenumgebung wieder hergestellt.
Object = My.Functions.Mathe.oSelected
LOCAL loSelected AS My_Fu_Selected loSelected = My.Functions.Mathe.oSelected */ Danach können Tabellen und Cursor geöffnet werden... */ Mit dem Nachfolgenden Befehl wird der obige Zustand der Datenumgebung wieder hergestellt RELEASE loSelected
Instanziiert einen temporären Thermos
Object = My.Functions.Mathe.oThermos
LOCAL loThermos AS My_Sy_Thermos */ Instanziieren loThermos = My.Functions.Mathe.oThermos loThermos.AutoCenter = .T. loThermos.cFaktor(1,1/10,.F.,"Info-1...") loThermos.cFaktor(1,2/10,.F.,"Info-2...") */ ... */ Schliesst den Thermos RELEASE loThermos
Siehe auch : Hauptmenü / Hauptindex / Such Index / Cursor Index / Programm Module / Tabellen Index / Tabellenmodule / Masken Index / Programmcode Index / Servicepacks / My.Struktur / Funktionen / Sonstiges Index
Lokale Benutzerhilfe : Meine eigene Hilfe / Zurück zur PMS32 - Hilfe
Dateiversion:1.0.04#3648 - H.U.DD#SSFF 02.12.2022
Senden Sie Ihren Kommentar zu diesem Thema an das Entwicklungsteam von PMS32
Weitere Informationen finden Sie unter der aktuellen
PMS32 WEB-Hilfe
Die Informationen dieser Mitteilung sind vertraulich und nur für Sie bestimmt. Unbefugtes Weiterleiten,
Veröffentlichen, Kopieren usw. sind untersagt und werden gerichtlich verfolgt.
© PMS Compelec GmbH 2022 ® el-Projekt