Arithmetische Operatoren und Rechenfunktionen

Arithmetische Operatoren

Grundrechenarten

   Debug.Print 2 + 3
   Debug.Print 2 - 3
   Debug.Print 2 * 3
   Debug.Print 3 / 2
   Debug.Print 3 \ 2       ' Ergebnis der Division ist abgeschnittene Ganzzahl, nicht gerundet!

Potenzrechnen

   Debug.Print 2 ^ 3       ' 2 hoch 3
   Debug.Print 4 ^ (1 / 2) ' Zweite Wurzel von 4
   Debug.Print Sqr(4)      ' Ebenfalls zweite Wurzel von 4
   Debug.Print 8 ^ (1 / 3) ' Dritte Wurzel von 8
   Debug.Print 3 ^ (-1)    ' 1 / 3

Gemischte Brüche

Der Modulo-Operator ermittelt den Rest einer ganzzahligen Division.

   Debug.Print 3 Mod 2     ' 3 : 2 ergibt Rest 1

Zusammen mit dem '\'-Operator, welcher den ganzzahligen Wert der Division zurückgibt, können Sie zum Beispiel folgendes Ergebnis als gemischten Bruch darstellen:

123 : 2 = 61
12
--
 03
  2
 --
  1       ' Ergebnis der Modulo-Operation

Ergebnis der Ganzzahligen Division:

lngResult =  123 \ 2     ' 61

Ergebnis der Modulo-Operation:

lngModulo = 123 Mod 2    ' 1

Ergebnis als zusammengesetzter gemischter Bruch:

Dividend    / Divisor   = Ganzzahliges Ergebnis + Modulo    /    Divisor
lngDividend  lngDivisor        lngResult        lngModulo     lngDivisor
   123      /     2     =          61               1       /     2

Eine entsprechende Funktion könnte wie folgt formuliert werden:

Public Function MixedFraction(ByVal lngNumerator As Long, ByVal lngDenominator As Long) As String
    ' created 2015-07-28 p.wania
    
    If lngDenominator = 0 Then
        MixedFraction = "Cannot divide by 0!"
        Exit Function
    End If
    MixedFraction = lngNumerator \ lngDenominator
    If lngNumerator Mod lngDenominator <> 0 Then
        MixedFraction = MixedFraction & " " & lngNumerator Mod lngDenominator & "/" & lngDenominator
    End If
End Function

Mathematische Funktionen

Winkelfunktionen

Bei den Winkelfunktionen wird der Winkel in Radianten erwartet:

Sin(dblRadiant)    ' Sinus
Cos(dblRadiant)    ' Kosinus
Tan(dblRadiant)    ' Tangens
Atn(dblRadiant)    ' Arkustangens

Radianten können wie folgt berechnet werden:

Public Function Radiants(ByVal dblDegrees As Double) As Double
  
    Radiants = dblDegrees * (4 * Atn(1)) / 180
End Function

Die Rückumrechnung in Grad erfolgt mit:

Public Function Degrees(ByVal dblRadiants As Double) As Double
  
    Degrees = dblRadiants * 180 / (4 * Atn(1))
End Function

Abgeleitete Funktionen / Formelsammlung

Folgende Formeln lassen sich von den eingebauten arithmetischen Formeln wie hier beschrieben ableiten:

Deutsch	Englisch	Formel
Sekans	Secant	dblSecant = 1 / Cos(dblNumber)
Kosekans	Cosecant	1 / Sin(X)
Kotangens	Cotangent	1 / Tan(X)
Arkussinus	Inverse Sine	Atn(X / Sqr(-X * X + 1))
Arkuskosinus	Inverse Cosine	Atn(-X / Sqr(-X * X + 1)) + 2 * Atn(1)
Arkussekans	Inverse Secant	Atn(X / Sqr(X * X – 1)) + Sgn((X) – 1) * (2 * Atn(1))
Arkuskosekans	Inverse Cosecant	Atn(X / Sqr(X * X - 1)) + (Sgn(X) – 1) * (2 * Atn(1))
Arkuskotangens	Inverse Cotangent	Atn(X) + 2 * Atn(1)
Sinus Hyperbolicus	Hyperbolic Sine	(Exp(X) – Exp(-X)) / 2
Kosinus Hyperbolicus	Hyperbolic Cosine	(Exp(X) + Exp(-X)) / 2
Tangens Hyperbolicus	Hyperbolic Tangent	(Exp(X) – Exp(-X)) / (Exp(X) + Exp(-X))
Sekans Hyperbolicus	Hyperbolic Secant	2 / (Exp(X) + Exp(-X))
Kosekans Hyperbolicus	Hyperbolic Cosecant	2 / (Exp(X) – Exp(-X))
Kotangens Hyperbolicus	Hyperbolic Cotangent	(Exp(X) + Exp(-X)) / (Exp(X) – Exp(-X))
Arkussinus Hyperbolicus	Inverse Hyperbolic Sine	Log(X + Sqr(X * X + 1))
Arkuskosinus Hyperbolicus	Inverse Hyperbolic Cosine	Log(X + Sqr(X * X – 1))
Arkustangens Hyperbolicus	Inverse Hyperbolic Tangent	Log((1 + X) / (1 – X)) / 2
Arkussekans Hyperbolicus	Inverse Hyperbolic Secant	Log((Sqr(-X * X + 1) + 1) / X)
Arkuskosekans Hyperbolicus	Inverse Hyperbolic Cosecant	Log((Sgn(X) * Sqr(X * X + 1) + 1) / X)
Arkuskotangens Hyperbolicus	Inverse Hyperbolic Cotangent	Log((X + 1) / (X – 1)) / 2
Logarithmus zur Basis N	Logarithm to base N	Log(X) / Log(N)

Diverse Funktionen

Vorzeichen ermitteln: Sgn

Die 'Sgn'-Funktion liefert das Vorzeichen einer Zahl zurück: '-1' bei negativen Zahlen, '0' beim Wert 0 und '1' bei positiven Zahlen.

Debug.Print Sgn(-123)         ' -1

Umwandlungen

Zeichenketten in Zahlen umwandeln

Vor der Umwandlung von Zeichenketten in Zahlen sollten Sie mit der 'IsNumeric'-Funktion prüfen, ob dies möglich ist:

   Dim strNumber As String
   Dim lngNumber As Long
   
   strNumber = InputBox("Bitte geben Sie eine natürliche Zahl ein:")
   If IsNumeric(strNumber) = True Then
       lngNumber = CLng(strNumber)
   End If

Die geläufigsten Umwandlungs-Funktionen sind:

CInt()
CLng()
CSng()
CDbl()
Val()

Nachkommastellen entfernen (Truncation)

Die Int- und Fix-Funktionen schneiden bei positiven Werten alle Nachkommastellen ab, sodass ausschließlich der ganzzahlige Wert erhalten bleibt:

lngWholeNumber = Int(1.01)        ' Ergibt 1
lngWholeNumber = Int(1.4)         ' Ergibt 1
lngWholeNumber = Int(1.5)         ' Ergibt 1
lngWholeNumber = Int(1.6)         ' Ergibt 1
lngWholeNumber = Int(1.99999999)  ' Ergibt 1

lngWholeNumber = Fix(1.01)        ' Ergibt 1
lngWholeNumber = Fix(1.4)         ' Ergibt 1
lngWholeNumber = Fix(1.5)         ' Ergibt 1
lngWholeNumber = Fix(1.6)         ' Ergibt 1
lngWholeNumber = Fix(1.99999999)  ' Ergibt 1

Bei negativen Werten verhalten sich beide Funktionen jedoch unterschiedlich:

• Die Int-Funktion ergibt weiterhin die nächst kleinere Ganzzahl:

lngWholeNumber = Int(-1.01)       ' Ergibt -2

• Die Fix-Funktion ergibt die nächst höhere Ganzzahl, wodurch alle Werte zwischen -0,999999999999 und +0,999999999999 den Wert 0 ergeben.

lngWholeNumber = Fix(-1.01)        ' Ergibt -1

Round, Fix, Int: Ein Vergleich

Die Unterschiede zwischen diesen Funktionen lassen sich am besten grafisch und anhand des Zufallszahlengenerators verdeutlichen:

• In den folgenden Grafiken wurden 100 Zufallszahlen zwischen -4 und 4 erzeugt und werden als blaue Punkte dargestellt.
• Die 'Rnd'-Funktion erzeugt Fließkommawerte zwischen 0 und 0,999999999999, also nicht ganz 1.
• Durch Anpassung des Anfangswertes und Multiplikation mit der Differenz zwischen Anfangs- und Endwert erhält man Zufallszahlen zwischen dem Anfangs- und Endwert, im Beispiel zwischen -4 und 3,999999999999.

Um aus diesem Wertebereich ganzzahlige Zufallszahlen zu generieren, stehen folgende Möglichkeiten zur Verfügung:

Runden mit 'Round'

Wenn wir nur den Bereich zwischen -3 und 3 betrachten, werden alle Werte zwischen zum Beispiel 0,5 und 1,4999999999 auf 1 gerundet und erzeugen so eine Wertespanne von etwa 1.

Allerdings zeichnet sich an den Endpunkten -3 und 3 ab, dass hier lediglich eine Wertespanne von etwa 0,5 zur Verfügung steht:

Angepasstes Runden mit 'Round'

Wird der Bereich auf -2,5 bis 3,5 erweitert, fallen den beiden Endpunkten jeweils vollständige Wertebereiche von 1 zu:

Nachkommastellen abschneiden mit 'Fix'

Ein alternativer Weg, aus Dezimalwerten Ganzzahlen zu erzeugen, besteht darin, die Nachkommastellen zu entfernen und somit nur den ganzzahligen Anteil zu behalten. Die 'Fix'-Funktion kann dies leisten, würde jedoch bei negativen Werten alle Werte von -0,9999999999 bis +0,9999999999 der 0 zuerteilen, wodurch diese einen doppelten Wertebereich abdecken würde.

Nachkommastellen abschneiden mit 'Int'

Die 'Int'-Funktion schneidet ebenfalls die Nachkommastellen ab, verhält sich aber bei negativen Werten anders als die 'Fix'-Funktion: Bei negativen Werten werden die nächst niedrigen Ganzzahlen zurückgeliefert (wie bei positiven Werten), also wird zum Beispiel aus -1,02 die -2.

In anderen Zahlensystemen darstellen

   ' Hex-Zahlen wird ein '&H' vorangestellt, um sie umzuwandeln
   Debug.Print &HFF1CE         ' 1044942
   Debug.Print Hex(1044942)    ' FF1CE

   Oct()

Formatieren

Die Formatierungsfunktionen

Die Format-Funktionen geben eine Zeichenkette zurück , welche den formatierten Wert darstellt. Bei den Zahlenfunktionen wird arithmetisch gerundet, NICHT mathematisch (siehe Runden)!

Debug.Print Format(Date, "d. mmmm yyyy")            ' 22. März 2016
Debug.Print FormatCurrency(23)                      ' 23,00 €
Debug.Print FormatDateTime(Date, vbLongDate)        ' Dienstag, 22. März 2016
Debug.Print FormatNumber(23.45, 1)                  ' 23,5
Debug.Print FormatPercent(0.12345)                  ' 12,35%

Wichtig bei der Formatierung von Datumsangaben

Die Formatfunktionen greifen auf Grundfunktionen des Betriebssystems zurück, deshalb können Datumsangaben (wie Digitale Werte) nicht immer korrekt interpretiert werden.

Folgende Werte wurden auf einem englischen Windows ermittelt:

    Debug.Print Format("1.1.2000", "yyyy-mm-dd")        ' 2206-08-23
    Debug.Print Format("01.01.2000", "yyyy-mm-dd")      ' 4670-10-04
    Debug.Print Format("11.1.2000", "yyyy-mm-dd")       ' 4944-07-19

Wie Sie sehen, sind die Ergebnisse nicht nur falsch, sondern weichen auch noch stark voneinander ab!

Es kann jedoch noch schlimmer kommen:

   Debug.Print Format("11.12.2000", "yyyy-mm-dd")      ' Laufzeitfehler: Überlauf!!

All dies lässt darauf zurückschließen, dass die zugrundeliegenden Funktionen zur Interpretation eines Datums von einem nichtdeutschen Betriebssystem nicht auf deutsch formatierte Datumsangaben angewendet werden können.

Wenn Sie mit Datumswerten arbeiten, die der Anwender zum Beispiel in einen Dialog eingibt, müssen Sie entweder selbst eine korrekte Umwandlungsfunktion schreiben oder Sie bitten den Anwender darum, das DIN Datumsformat ('yyyy-mm-dd') zu verwenden, denn dieses kann auf jeder von uns getestetet Sprachversion von Windows korrekt interpretiert werden.

Zahlensysteme

Binärsystem (Basis 2)

Das Binärsystem stellt numerische Werte ausschließlich mit den Ziffern '0' und '1' dar, wodurch es zur Verwendung in elektronischen Rechensystemen prädestiniert ist, denn '1' und '0' lassen sich sehr gut in die Zustände 'an' und 'aus' bzw. 'wahr' und 'falsch' oder 'geschlossen' und 'offen' übertragen.

Dezimalzahl	Binärwert
0	0
1	1
2	10
3	11
4	100
5	101
12	1100
16	10000
123456789	111010110111100110100010101

Bitte beachten: Binärzahlen werden in den folgenden Beispielen in Zeichenketten aufgenommen, um eventuell benötigte führende Nullen zu behalten.

Ganzzahlen binär darstellen

VBA bietet hierfür keine eigene Funktion an, aber mit folgender Funktion wird dies gelingen:

Public Function Long2Binary(ByVal lngValue As Long) As String
    
    Do Until lngValue = 0
        Long2Binary = Format(lngValue - 2 * Int(lngValue / 2)) & Long2Binary
        lngValue = Int(lngValue / 2)
    Loop
End Function

Binärwerte in Ganzzahlen umwandeln

VBA kann nicht direkt Binärwerte in Ganzzahlen umwandeln, aber mit der folgender Funktion wird dies ermöglicht:

Public Function Binary2Long(ByVal strBinary As String) As Long
    Dim lngIndex As Long
    Dim lngMax As Long
    
    lngMax = Len(strBinary)
    For lngIndex = 0 To (lngMax - 1)
        Binary2Long = Binary2Long + CLng(Mid(strBinary, lngMax - (lngIndex), 1)) * (2 ^ lngIndex)
    Next
End Function

Oktalsystem (Basis 8)

Im Oktalsystem erfolgt der Wechsel auf die nächst höhere Stelle schon bei der 8, wordurch die Zahlen schnell mehr Stellen haben als im Dezimalsystem. Es findet inzwischen kaum noch Anwendung in der Programmierung, kann aber in VBA weiterhin verwendet und interpretiert werden.

Dezimalzahl	OCT-Wert
0	0
1	1
2	2
3	3
4	4
5	5
6	6
7	7
8	10
9	11
10	12
11	13
12	14
16	20
24	30
123456789	726746425

Oct-Funktion: Ganzzahlen in Oktalwerte umwandeln

Die Oct-Funktion wandelt eine Ganzzahl in einen Oktalwert um:

Debug.Print Oct(123456789)           ' 726746425

Oktalwerte in Ganzzahlen umwandeln

Oktalwerte werden von VBA direkt und automatisch in Ganzzahlen umgewandelt, sobald ein '&O' der Zahl vorangestellt ist.

• Direkte Eingabe im Editor:

   Debug.Print &O726746425            ' 123456789

• Übernahme eines oktalen Wertes aus einer Variablen, einem Eingabefeld oder ähnlichem mithilfe der 'CLng'-Funkton:

   Dim strOct As String
   
   strOct = "726746425"
   Debug.Print CLng("&O" & strOct)   ' 123456789

Dezimalsystem (Basis 10)

Das Dezimalsystem ist das weltweit übliche Zahlensystem und wird von VBA direkt zur Darstellung und Eingabe von Werten verwendet und unterstützt.

Hexadezimalsystem (Basis 16)

Im hexadezimalen Zahlensystem erfolgt erst mit 16 der erste Wechsel in die höhere Stelle, wodurch große Zahlen mit weniger Stellen dargestellt werden können. Da jedoch für die Darstellung von Ziffern keine 15 Einzelziffern zur Verfügung stehen, ist man auf die Repräsentation der Ziffern von 10 bis 15 mithilfe der Buchstaben A bis F ausgewichen. Dies wiederum führt dazu, dass hexadezimale Zahlen nur in Zeichenketten untergebracht werden können, nicht in numerischen Datentypen.

Dezimalzahl	HEX-Wert
0	0
1	1
2	2
3	3
4	4
5	5
6	6
7	7
8	8
9	9
10	A
11	B
12	C
13	D
14	E
15	F
16	10
17	11
18	12
19	13
32	20
64	30
160	A0
161	A1
255	FF
123456789	75BCD15

Hex-Funktion: Ganzzahlen in Hexadezimalwerte umwandeln

Die Hex-Funktion wandelt eine Ganzzahl in einen Hexadezimalwert um:

Debug.Print Hex(123456789)           ' 75BCD15

Hexadezimalwerte in Ganzzahlen umwandeln

Hexadezimalwerte werden von VBA direkt und automatisch in Ganzzahlen umgewandelt, sobald ein '&H' der Hex-Zahl vorangestellt ist.

• Direkte Eingabe im Editor:

   Debug.Print &H75BCD15             ' 123456789

• Übernahme eines Hexadezimalen Wertes aus einer Variablen, einem Eingabefeld oder ähnlichem mithilfe der 'CLng'-Funkton:

   Dim strHex As String
   
   strHex = "75BCD15"
   Debug.Print CLng("&H" & strHex)   ' 123456789

Standardlösungen

Runden

VBA verwendet beim Runden das bei Programmiersprachen übliche 'mathematische Runden', welches den Wert #,5 zur nächsten geraden Zahl rundet (siehe Wikipedia).

Wenn Sie immer zur nächsten Ganzzahl runden möchten (arithmetisches Runden), verwenden Sie folgende Funktion:

Public Function RoundArithmetically(ByVal dblNumber As Double, Optional ByVal lngDigits As Long = 0) As Double
    Dim lngFactor As Long
    
    lngFactor = 1
    If dblNumber < 0 Then
       lngFactor = -1
       dblNumber = Abs(dblNumber)
    End If
    RoundArithmetically = lngFactor * Int(dblNumber * 10 ^ lngDigits + 0.5) / 10 ^ lngDigits
End Function

Alternativ kann ebensogut die 'FormatNumber'-Funktion eingesetzt werden, welche von Natur aus arithmetisch rundet:

Public Function RoundArithmetically(ByVal dblNumber As Double, Optional ByVal lngDigits As Long = 0) As Double
   
    RoundArithmetically = FormatNumber(dblNumber, lngDigits)
End Function

Zufallszahlen

Um die eigentliche Funktionalität, nämlich eine Zufallszahl zu generieren, nur einmal Programmieren zu müssen, aber in mehreren Situationen verwenden zu können, wird hier ausschließlich die Funktion RandomDouble mit dem Zufallszahlengenerator ausgestattet:

Public Function RandomDouble(ByVal dblBottom As Double, ByVal dblTop As Double, _
                                                  Optional ByVal lngRoundToDigits As Long = -1) As Double
    ' created 2015-06-24 p.wania

    Randomize
    RandomDouble = dblBottom + Rnd() * (dblTop - dblBottom)
    If lngRoundToDigits >= 0 Then
        RandomDouble = Round(RandomDouble, lngRoundToDigits)
    End If
End Function

Die Funktion RandomLong bedient sich lediglich derer und wandelt das Ergebnis entsprechend um (siehe auch Round, Fix, Int: Ein Vergleich):

Public Function RandomLong(ByVal lngBottom As Long, ByVal lngTop As Long) As Long
    ' created 2015-06-24 p.wania
    
    RandomLong = Int(RandomDouble(lngBottom, lngTop + 1))
End Function

So wäre es zum Beispiel denkbar, eine Funktion RandomCharacter zu erstellen, welche mithilfe einer Zufallszahl einen Zufallsbuchstaben aus einer Liste von Buchstaben ermittelt.

Mathematische Konstanten

Folgende mathematische Konstanten müssen mithilfe von Mathematischen Funktionen selbst errechnet werden:

Deutsch	Englisch	Formel
Pi	Pi	dblPi = 4 * Atn(1)
Eulersche Zahl e	Euler's number e	dblEulersNumber = Exp(1)

Logarithmus

Mit der folgenden Funktion errechnen Sie den Logarithmus zu einer vorgegebenen Basis:

Public Function Logarithm(ByVal dblValue As Double, ByVal dblBase As Double)
    
    If dblValue < 0 Or dblBase < 0 Then
        MsgBox "Der Logarithmus kann nur über positive Zahlen bestimmt werden!"
        Exit Function
    End If
    Logarithm = Log(dblValue) / Log(dblBase)
End Function