Mit Werten arbeiten: 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.Print 3 \ 2 ' Ergebnis…“)
 
(Der Seiteninhalt wurde durch einen anderen Text ersetzt: „* Mit Zahlen rechnen * Zeichenketten|Texte zusammensetzen, auseinanderschneiden,…“)
Zeile 1: Zeile 1:
== Arithmetische Operatoren ==
* [[Arithmetische Operatoren und Rechenfunktionen|Mit Zahlen rechnen]]
 
* [[Zeichenketten|Texte zusammensetzen, auseinanderschneiden, vergleichen]]
=== Grundrechenarten ===
* [[Rechnen mit Datumswerten|Mit Minuten, Monaten, Quartalen und Jahren rechnen]]
 
* [[Farben|Mit Farben arbeiten]]
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!
* [[Collection|Auflistungen erstellen, bearbeiten, weiterreichen]]
 
* [[Array|Datenfelder bezwingen]]
=== Potenzrechnen ===
* [[Objekte beherrschen]]
 
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 23. November 2017, 13:35 Uhr

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