Rechnen mit Zahlen und Werten: Unterschied zwischen den Versionen

Aus VBA-wiki
Zur Navigation springen Zur Suche springen
(Die Seite wurde neu angelegt: „== Arithmetische Operatoren == === Grundrechenarten === Debug.Print 2 + 3 Debug.Print 2 - 3 Debug.Print 2 * 3 Debug.Print 3 / 2 Debug.Pri…“)
 
(Die Seite wurde geleert.)
Zeile 1: Zeile 1:
== 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<span style="Color:gray">.</span>Print <span style="Color:gray">3</span> Mod <span style="Color:gray">2</span>    <span style="Color:green">' 3 : 2 ergibt Rest 1</span>
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:
{|class="wikitable"
! style="text-align:left;" |Deutsch
! style="text-align:left;" |Englisch
! style="text-align:left;" |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:
[[Datei:Round010.png|800px]]
; 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:
[[Datei:Round02.png|800px]]
; 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.
[[Datei:Fix.png|800px]]
; 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.
[[Datei:Int.png|800px]]
=== 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 Format-Funktionen geben eine Zeichenkette zurück , welche den formatierten Wert darstellt. Bei den Zahlenfunktionen wird arithmetisch gerundet, NICHT mathematisch (siehe [[#Runden|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%
== 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.
{| class="wikitable"
|-
! 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.
{| class="wikitable"
|-
! 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.
{| class="wikitable"
|-
! 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 [https://de.wikipedia.org/wiki/Rundung#Rundung_im_Computer 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  <code>RandomDouble</code> 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 <code>RandomLong</code> bedient sich lediglich derer und wandelt das Ergebnis entsprechend um (siehe auch [[#Round, Fix, Int: Ein Vergleich|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 <code>RandomCharacter</code> 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:
{|class="wikitable"
! style="text-align:left;" |Deutsch
! style="text-align:left;" |Englisch
! style="text-align:left;" |Formel
|-
| Pi
| Pi
|
dblPi = 4 * Atn(1)
|-
| Eulersche Zahl<br>e
| Euler's number<br>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

Version vom 13. Januar 2021, 17:10 Uhr

Abgerufen von „http://vba-wiki.net/index.php?title=Rechnen_mit_Zahlen_und_Werten&oldid=649“