; #INDEX# =======================================================================================================================
; Titel..........: MathEx
; AutoIt Version.: 3.3.0.0 ++
; Sprache........: Deutsch
; Beschreibung...: Diese UDF ergänzt um einige mathematische Funktionen.
; Version........: 3.0.0.0
; ===============================================================================================================================

; #AUTHOR(S)# ===================================================================================================================
; Hauptentwickler: Matthias Gianfelice
; Mitentwickler..: BugFix, eukalyptus, Progandy, Deepred, AutoBert, Stilgar, L3viathan2142, Niko H.
;
;   >> !! Danke an die ganze deutsche AutoIt Community !! <<
;
; ===============================================================================================================================

; #CURRENT# =====================================================================================================================
; _MathEx_Checksum
; _MathEx_IsDivisible
; _MathEx_IsPrime
; _MathEx_Pi
; _MathEx_Max
; _MathEx_Min
; _MathEx_CreatePrimes
; _MathEx_IsNumber
; _MathEx_Sqrt
; _MathEx_Mean
; _MathEx_Log
; _MathEx_IsEven
; _MathEx_PQ
; _MathEx_StandardDeviation
; _MathEx_GGT
; _MathEx_KGV
; _MathEx_Factorial
; _MathEx_Eul
; _MathEx_Point_Distance
; _MathEx_Point_InRectangle
; _MathEx_GraphInfo
; _MathEx_Point_OnLine
; _MathEx_Point_OnSegment
; ===============================================================================================================================

; #FUNCTION# ====================================================================================================================
; Name...........: _MathEx_Checksum
; Beschreibung...: Gibt die Quersumme einer Zahl zurück.
; Syntax.........: _MathEx_Checksum($number[, $modus=0])
; Parameter......: $number - Die Nummer, dessen Quersumme ermittelt werden soll
;                  $modus - Welche Quersumme zurückgegeben werden soll: 0: normal; 1:iterativ; 2:alternativ
; Rückgaben......: Erfolg - Die Quersumme
;                  Fehler - False, wenn $number oder $modus ungültig sind.
; Autor(en)......: BugFix <BugFix at autoit dot de>, Matthias Gianfelice <matthias at gianfelice dot de>
; ===============================================================================================================================
Func _MathEx_Checksum($number, $modus = 0)
	Local $integer_number_mathex_checksum = Number($number)
	If Not _MathEx_IsNumber($integer_number_mathex_checksum) Or Not $integer_number_mathex_checksum > 0 Or Not IsInt($modus) Then Return False
	While StringLen($integer_number_mathex_checksum) > 1
		Local $array_number_mathex_checksum = StringSplit($integer_number_mathex_checksum, '', 2)
		$integer_number_mathex_checksum = 0
		If $modus = 2 Then
			Local $mul = -1
			For $i = UBound($array_number_mathex_checksum) - 1 To 1 Step -1
				$array_number_mathex_checksum[$i - 1] = $array_number_mathex_checksum[$i] + ($mul * $array_number_mathex_checksum[$i - 1])
				$mul *= -1
			Next
			Return $array_number_mathex_checksum[0]
		Else
			For $i = 0 To UBound($array_number_mathex_checksum) - 1
				$integer_number_mathex_checksum += $array_number_mathex_checksum[$i]
			Next
			If $modus = 0 Then ExitLoop
		EndIf
	WEnd
	Return $integer_number_mathex_checksum
EndFunc   ;==>_MathEx_Checksum

; #FUNCTION# ====================================================================================================================
; Name...........: _MathEx_IsDivisible
; Beschreibung...: Prüft, ob eine Zahl durch eine andere teilbar ist.
; Syntax.........: _MathEx_IsPrime($numdividend, $numdivisor)
; Parameter......: $numdividend - Der Dividend
;				   $numdivisor - Der Divisor
; Rückgaben......: Erfolg - Gibt 1 zurück, wenn der Dividend durch den Divisor teilbar ist, gibt 0 zurück, wenn nicht.
;                  Fehler - Gibt -1 zurück und setzt @error
;                  |0 - $numdividend und $numdivisor sind nicht teilbar
;				   |1 - $numdivisor ist 0
; Autor(en)......: eukalyptus <eukalyptus at autoit dot de>, Matthias Gianfelice <matthias at gianfelice dot de>
; ===============================================================================================================================
Func _MathEx_IsDivisible($numdividend, $numdivisor)
	If Not _MathEx_IsNumber($numdividend) Or Not _MathEx_IsNumber($numdivisor) Then
		SetError(2)
		Return -1
	EndIf
	If $numdivisor = 0 Then
		SetError(1)
		Return -1
	EndIf
	If Not Mod($numdividend, $numdivisor) Then
		Return 1
	Else
		Return 0
	EndIf
EndFunc   ;==>_MathEx_IsDivisible

; #FUNCTION# ====================================================================================================================
; Name...........: _MathEx_IsPrime
; Beschreibung...: Prüft, ob eine Zahl eine Primzahl ist.
; Syntax.........: _MathEx_IsPrime($number[, $one_prime])
; Parameter......: $number - Die Nummer, die geprüft werden soll
;                  $one_prime - Auf 1 setzen, wenn 1 eine Primzahl sein soll.
; Rückgabe.......: Erfolg - Gibt 1 zurück, wenn die Zahl eine Primzahl ist, 0 wenn nicht
;                  Fehler - Gibt -1 zurück, wenn $number keine Zahl ist, oder $one_prime ungültig ist.
; Author ........: Progandy <Progandy at autoit dot de>, Matthias Gianfelice <matthias at gianfelice dot de>
; ===============================================================================================================================
Func _MathEx_IsPrime($number, $one_prime = 0)
	If Not _MathEx_IsNumber($number) Or Not IsInt($one_prime) Or $one_prime > 1 Or $one_prime < 0 Then Return -1
	If $one_prime And $number = 1 Then Return 1
	If $number = 1 Then Return 0
	If $number = 2 Then Return 1
	If Mod($number, 2) = 0 Then Return 0
	For $i = 3 To Sqrt($number) Step 2
		If Mod($number, $i) = 0 Then Return 0
	Next
	Return 1
EndFunc   ;==>_MathEx_IsPrime

; #FUNCTION# ====================================================================================================================
; Name...........: _MathEx_Pi
; Beschreibung...: Gibt Pi relativ genau zurück
; Syntax.........: _MathEx_Pi()
; Rückgaben......: Erfolg - Gibt Pi zurück
; Autor(en)......: Stilgar <Stilgar at autoit dot de>, Deepred <Deepred at autoit dot de>,
;                  Matthias Gianfelice <matthias at gianfelice dot de>
; ===============================================================================================================================
Func _MathEx_Pi()
	Return 4 * ATan(1)
EndFunc   ;==>_MathEx_Pi

; #FUNCTION# ====================================================================================================================
; Name...........: _MathEx_Max
; Beschreibung...: Gibt die größte Zahl in einem Array zurück.
; Syntax.........: _MathEx_Max($aNumbers[, $mode = 0])
; Parameter......: $aNumbers - 0-basiertes Array mit den Zahlen
;				   $mode - Was zurückgegeben werden soll:
;						|0: Die größte Nummer
;						|1: Die ID der größten Nummer im Array
;						|2: Beides wird in einem Array zurückgegeben: 0 enthält die größte Nummer und 1 die ID.
; Rückgabe.......: Erfolg - Gibt einen String, eine Nummer oder ein Array zurück
;                  Fehler - Gibt -1 zurück und setzt @error
;						|1 - $aNumbers ist kein Array oder $mode ist kein Integer
;						|2 - Eine Nummer im Array ist keine Zahl, @extended enthält die Id
; Bemerkungen....: Wenn mehrere "größte" Zahlen enthalten sind, wird die erste zurückgegeben
; Autor(en)......: Matthias Gianfelice <matthias at gianfelice dot de>
; ===============================================================================================================================
Func _MathEx_Max($aNumbers, $mode = 0)
	If Not IsArray($aNumbers) Or Not IsInt($mode) Then
		SetError(1)
		Return -1
	EndIf
	For $i = 0 To UBound($aNumbers) - 1
		If Not _MathEx_IsNumber($aNumbers[$i]) Then
			SetError(2, $i)
			Return -1
		EndIf
	Next
	Local $integer_mathex_maximal_nummer = 0
	For $i = 0 To UBound($aNumbers) - 1
		If Number($aNumbers[$i]) > $aNumbers[$integer_mathex_maximal_nummer] Then $integer_mathex_maximal_nummer = $i
	Next
	Switch $mode
		Case 0
			Return $aNumbers[$integer_mathex_maximal_nummer]
		Case 1
			Return $integer_mathex_maximal_nummer
		Case 2
			Local $array_mathex_number_final[2] = [$aNumbers[$integer_mathex_maximal_nummer], $integer_mathex_maximal_nummer]
			Return $array_mathex_number_final
	EndSwitch
EndFunc   ;==>_MathEx_Max

; #FUNCTION# ====================================================================================================================
; Name...........: _MathEx_Min
; Beschreibung...: Gibt die kleinste Zahl in einem Array zurück.
; Syntax.........: _MathEx_Min($aNumbers[, $mode = 0])
; Parameter......: $aNumbers - 0-basiertes Array mit den Zahlen
;				   $mode - Was zurückgegeben werden soll:
;						|0: Die kleinste Nummer
;						|1: Die ID der größten Nummer im Array
;						|2: Beides wird in einem Array zurückgegeben: 0 enthält die kleinste Nummer und 1 die ID.
; Rückgabe.......: Erfolg - Gibt einen String, eine Nummer oder ein Array zurück
;                  Fehler - Gibt -1 zurück und setzt @error
;						|1 - $aNumbers ist kein Array oder $mode ist kein Integer
;						|2 - Eine Nummer im Array ist keine Zahl, @extended enthält die Id
; Bemerkungen....: Wenn mehrere "kleinste" Zahlen enthalten sind, wird die erste zurückgegeben
; Autor(en)......: Matthias Gianfelice <matthias at gianfelice dot de>
; ===============================================================================================================================
Func _MathEx_Min($aNumbers, $mode = 0)
	If Not IsArray($aNumbers) Or Not IsInt($mode) Then
		SetError(1)
		Return -1
	EndIf
	For $i = 0 To UBound($aNumbers) - 1
		If Not _MathEx_IsNumber($aNumbers[$i]) Then
			SetError(2, $i)
			Return -1
		EndIf
	Next
	Local $integer_mathex_minimal_nummer = 0
	For $i = 0 To UBound($aNumbers) - 1
		If Number($aNumbers[$i]) < $aNumbers[$integer_mathex_minimal_nummer] Then $integer_mathex_minimal_nummer = $i
	Next
	Switch $mode
		Case 0
			Return $aNumbers[$integer_mathex_minimal_nummer]
		Case 1
			Return $integer_mathex_minimal_nummer
		Case 2
			Local $array_mathex_number_final[2] = [$aNumbers[$integer_mathex_minimal_nummer], $integer_mathex_minimal_nummer]
			Return $array_mathex_number_final
	EndSwitch
EndFunc   ;==>_MathEx_Min

; #FUNCTION# ====================================================================================================================
; Name...........: _MathEx_CreatePrimes
; Beschreibung...: Gibt ein Array voller Primzahlen zurück.
; Syntax.........: _MathEx_CreatePrimes($number)
; Parameter......: $number - Zwischen 2 und $number werden die Primzahlen gesucht
; Rückgaben......: Erfolg - Gibt ein Array zurück. Im 0ten Element steht die Anzahl an Zahlen, im Rest die Primzahlen selbst.
;                  Fehler - Gibt 0 zurück, wenn $number kein Integer ist oder kleiner als 2 ist
; Autor(en)......: AutoBert <AutoBert at autoit dot de>, Progandy <Progandy at autoit dot de>,
;                  Matthias Gianfelice <matthias at gianfelice dot de>
; ===============================================================================================================================
Func _MathEx_CreatePrimes($number)
	If Not IsInt($number) Or $number < 2 Or $number > 16777215 Then Return 0
	$number += 3
	Local $array_mathex_gestrichen[$number - 2]
	For $i = 0 To $number - 3
		$array_mathex_gestrichen[$i] = False
	Next
	Local $i = 2
	While $i * $i <= $number
		If Not $array_mathex_gestrichen[$i] Then
			For $j = $i * $i To $number - 3 Step $i
				$array_mathex_gestrichen[$j] = True
			Next
		EndIf
		$i = $i + 1
	WEnd
	Local $integer_mathex_anzahl = 0
	For $i = 2 To $number - 3
		If Not $array_mathex_gestrichen[$i] Then $integer_mathex_anzahl += 1
	Next
	Local $array_mathex_primzahlen[$integer_mathex_anzahl + 1], $integer_mathex_aktuell = 1
	$array_mathex_primzahlen[0] = $integer_mathex_anzahl
	For $i = 2 To $number - 3
		If Not $array_mathex_gestrichen[$i] Then
			$array_mathex_primzahlen[$integer_mathex_aktuell] = $i
			$integer_mathex_aktuell += 1
		EndIf
	Next
	Return $array_mathex_primzahlen
EndFunc   ;==>_MathEx_CreatePrimes

; #FUNCTION# ====================================================================================================================
; Name...........: _MathEx_IsNumber
; Beschreibung...: Prüft, ob ein String gleich einer Nummer ist.
; Syntax.........: _MathEx_IsNumber($number)
; Parameter......: $number - Der String, der geprüft werden soll.
; Rückgaben......: Gibt 1 zurück, wenn der String eine Zahl ist, oder 0 wenn es nicht der Fall ist.
; Autor(en)......: Matthias Gianfelice <matthias at gianfelice dot de>
; ===============================================================================================================================
Func _MathEx_IsNumber($number)
	If Not Number($number) = 0 Then
		Return 1
	ElseIf $number == "0" Or $number == 0 Then
		Return 1
		MsgBox(0, "", "")
	Else
		Return 0
	EndIf
EndFunc   ;==>_MathEx_IsNumber

; #FUNCTION# ====================================================================================================================
; Name...........: _MathEx_Sqrt
; Beschreibung...: Gibt die nte Wurzel von einer Zahl zurück.
; Syntax.........: _MathEx_Sqrt($number[, $sqrt=2])
; Parameter......: $number - Die Nummer, aus der die Wurzel gezogen werden soll
;                  $sqrt - Welche Wurzel gezogen werden soll
; Rückgaben......: Erfolg - Gibt die Wurzel zurück
;                  Fehler - Gibt -1 zurück und setzt @error:
;							|1: $number oder $sqrt ist keine Nummer
;							|2: $number ist negativ
; Autor(en)......: Matthias Gianfelice <matthias at gianfelice dot de>
; ===============================================================================================================================
Func _MathEx_Sqrt($number, $sqrt = 2)
	If Not _MathEx_IsNumber($number) Or Not _MathEx_IsNumber($sqrt) Then
		SetError(1)
		Return -1
	EndIf
	If $number < 0 Then
		SetError(2)
		Return -1
	EndIf
	Return $number ^ (1 / $sqrt)
EndFunc   ;==>_MathEx_Sqrt

; #FUNCTION# ====================================================================================================================
; Name...........: _MathEx_Mean
; Beschreibung...: Gibt das Mittel einer Zahl zurück
; Syntax.........: _MathEx_Mean($aNumbers[, $modus=3])
; Parameter......: $aNumbers - Ein 0-basiertes Array mit allen Zahlen
;                  $modus - Welches Mittel verwendet werden soll (nach größe (HM <= GM <= AM <= QM))
;							|1: harmonisches Mittel; 2: geometrisches Mittel; 3 (Standart): arithmetisches Mittel;
;							|4: quadratisches Mittel
; Rückgaben......: Erfolg - Das jeweilige Mittel
;                  Fehler - Gibt False zurück und setzt @error:
;							|1: $aNumbers ist kein Array oder $modus ist ungültig
;							|2: Min. ein Arrayelement ist keine Zahl, in @extended steht die ID des jeweiligen
; Autor(en)......: Stilgar <Stilgar at autoit dot de>, Matthias Gianfelice <matthias at gianfelice dot de>
; ===============================================================================================================================
Func _MathEx_Mean($aNumbers, $mode = 3)
	If Not IsArray($aNumbers) Or Not IsInt($mode) Or $mode < 1 Or $mode > 4 Then
		SetError(1)
		Return False
	EndIf
	For $i = 0 To UBound($aNumbers) - 1
		If Not _MathEx_IsNumber($aNumbers[$i]) Then
			SetError(2, $i)
			Return False
		EndIf
	Next
	Local $integer_mathex_ubound = UBound($aNumbers), $number_mathex_temp = 0
	Switch $mode
		Case 1 ; harmonisches Mittel
			For $i = 0 To $integer_mathex_ubound - 1
				$number_mathex_temp += 1 / $aNumbers[$i]
			Next
			$number_mathex_temp = $integer_mathex_ubound / $number_mathex_temp
		Case 2 ; geometrisches Mittel
			$number_mathex_temp = 1
			For $i = 0 To $integer_mathex_ubound - 1
				$number_mathex_temp = $number_mathex_temp * $aNumbers[$i]
			Next
			$number_mathex_temp = _MathEx_Sqrt($number_mathex_temp, $integer_mathex_ubound)
			If @error Then SetError(4, 0, "")
		Case 3 ; arithmetisches Mittel
			For $i = 0 To $integer_mathex_ubound - 1
				$number_mathex_temp += $aNumbers[$i]
			Next
			$number_mathex_temp = $number_mathex_temp / $integer_mathex_ubound
		Case 4 ; quadratisches Mittel
			For $i = 0 To $integer_mathex_ubound - 1
				$number_mathex_temp += $aNumbers[$i] ^ 2
			Next
			$number_mathex_temp = Sqrt($number_mathex_temp / 2)
	EndSwitch
	Return $number_mathex_temp
EndFunc   ;==>_MathEx_Mean

; #FUNCTION# ====================================================================================================================
; Name...........: _MathEx_Log
; Beschreibung...: Gibt den Logarithmus einer Zahl zurück
; Syntax.........: _MathEx_Log($nbasis, $nlog)
; Parameter......: $nbasis - Die Basis
;                  $nlog - Die Zahl
; Rückgaben......: Erfolg - Der Logarithmus zur Basis $nbasis von $nlog
;                  Fehler - Gibt False zurück, wenn eine der beiden Nummern keine Zahl ist.
; Autor(en)......: Matthias Gianfelice <matthias at gianfelice dot de>
; ===============================================================================================================================
Func _MathEx_Log($nbasis, $nlog)
	If Not _MathEx_IsNumber($nbasis) Or Not _MathEx_IsNumber($nlog) Then Return False
	Return Log($nlog) / Log($nbasis)
EndFunc   ;==>_MathEx_Log

; #FUNCTION# ====================================================================================================================
; Name...........: _MathEx_IsEven
; Beschreibung...: Prüft, ob eine Zahl gerade ist
; Syntax.........: _MathEx_IsEven($number)
; Parameter......: $number - Die Nummer, die geprüft werden soll
; Rückgaben......: Erfolg - Gibt 1 zurück, wenn die Zahl gerade ist und 0, wenn nicht
;                  Fehler - Gibt -1 zurück, wenn $number keine Nummer ist
; Autor(en)......: Matthias Gianfelice <matthias at gianfelice dot de>
; ===============================================================================================================================
Func _MathEx_IsEven($number)
	If Not _MathEx_IsNumber($number) Then Return -1
	If Mod($number, 2) = 0 Then
		Return 1
	Else
		Return 0
	EndIf
EndFunc   ;==>_MathEx_IsEven

; #FUNCTION# ====================================================================================================================
; Name...........: _MathEx_PQ
; Beschreibung...: Errechnet aus den Variablen p und q die quadratische Ergänzung
; Syntax.........: _MathEx_PQ($p, $q)
; Parameter......: $p - p
;                  $q - q
; Rückgaben......: Erfolg - Ein Array, dessen beide Elemente die Lösungen enthalten
;                  Fehler - False, falls die Wurzel negativ werden würde oder p bzw. q keine Zahlen sind
; Autor(en)......: Deepred <Deepred at autoit dot de>, L3viathan2142 <L3viathan2142 at autoit dot de>,
;                  Matthias Gianfelice <matthias at gianfelice dot de>
; ===============================================================================================================================
Func _MathEx_PQ($p, $q)
	If Not _MathEx_IsNumber($p) Or Not _MathEx_IsNumber($q) Then Return False
	Local $number_mathex_sqrt = $p ^ 2 / 4 - $q, $number_mathex_other = $p / - 2
	If $number_mathex_sqrt < 0 Then Return False
	$number_mathex_sqrt = Sqrt($number_mathex_sqrt)
	Local $return_array[2] = [$number_mathex_other + $number_mathex_sqrt, $number_mathex_other - $number_mathex_sqrt]
	Return $return_array
EndFunc   ;==>_MathEx_PQ

; #FUNCTION# ====================================================================================================================
; Name...........: _MathEx_StandardDeviation
; Beschreibung...: Gibt die Standardabweichung übergebener Zahlen an
; Syntax.........: _MathEx_StandardDeviation($aNumbers)
; Parameter......: $aNumbers - Ein 0-basiertes Array mit allen Zahlen
; Rückgaben......: Erfolg - Die Standardabweichung
;                  Fehler - Gibt False zurück und setzt @error:
;							|1: $aNumbers ist kein Array
;							|2: Min. ein Arrayelement ist keine Zahl, in @extended steht die ID des jeweiligen
; Autor(en)......: Matthias Gianfelice <matthias at gianfelice dot de>
; ===============================================================================================================================
Func _MathEx_StandardDeviation($aNumbers)
	If Not IsArray($aNumbers) Then
		SetError(1)
		Return False
	EndIf
	Local $integer_mathex_ubound = UBound($aNumbers), $number_mathex_temp = 0, $number_mathex_mittel = _MathEx_Mean($aNumbers)
	For $i = 0 To $integer_mathex_ubound - 1
		If Not _MathEx_IsNumber($aNumbers[$i]) Then
			SetError(2, $i)
			Return False
		EndIf
		$number_mathex_temp += ($aNumbers[$i] - $number_mathex_mittel) ^ 2
	Next
	Return Sqrt($number_mathex_temp / ($integer_mathex_ubound - 1))
EndFunc   ;==>_MathEx_StandardDeviation

; #FUNCTION# ====================================================================================================================
; Name...........: _MathEx_GGT
; Beschreibung...: Gibt den größten gemeinsamen Teiler von 2 Zahlen an (nach euklidischem Algorithmus)
; Syntax.........: _MathEx_GGT($numbera, $numberb)
; Parameter......: $numbera, $numberb - Zwei beliebige Zahlen
; Rückgabe.......: Erfolg - Gibt einen Integer zurück
;                  Fehler - Gibt False zurück, wenn es sich nicht um Zahlen handelt
; Autor(en)......: Niko H. <ChaosKeks at autoit dot de>, Matthias Gianfelice <matthias at gianfelice dot de>
; ===============================================================================================================================
Func _MathEx_GGT($numbera, $numberb)
	If Not _MathEx_IsNumber($numbera) Or Not _MathEx_IsNumber($numberb) Then Return False
	If $numbera = 0 Or $numberb = 0 Then Return 1
	Local $number_mathex_rest1 = $numbera, $number_mathex_rest2 = $numberb, $number_mathex_temp
	Do
		$number_mathex_temp = Mod($number_mathex_rest1, $number_mathex_rest2)
		$number_mathex_rest1 = $number_mathex_rest2
		$number_mathex_rest2 = $number_mathex_temp
	Until $number_mathex_temp = 0
	Return $number_mathex_rest1
EndFunc   ;==>_MathEx_GGT

; #FUNCTION# ====================================================================================================================
; Name...........: _MathEx_KGV
; Beschreibung...: Gibt das kleinste gemeinsame Vielfache von 2 Zahlen an
; Syntax.........: _MathEx_kgV($numbera, $numberb)
; Parameter......: $numbera, $numberb - Zwei beliebige Zahlen
; Rückgabe.......: Erfolg - Gibt einen Integer zurück
;                  Fehler - Gibt False zurück, wenn es sich nicht um Zahlen handelt
; Autor(en)......: Niko H. <ChaosKeks at autoit dot de>, Matthias Gianfelice <matthias at gianfelice dot de>
; ===============================================================================================================================
Func _MathEx_KGV($numbera, $numberb)
	Local $number_mathex_ggt = _MathEx_GGT($numbera, $numberb)
	If $number_mathex_ggt = False Then Return False
	Return $numbera * $numberb / $number_mathex_ggt
EndFunc   ;==>_MathEx_KGV

; #FUNCTION# ====================================================================================================================
; Name...........: _MathEx_Factorial
; Beschreibung...: Gibt eine beliebige Fakultät zurück
; Syntax.........: _MathEx_Factorial($number[, $mode = 0])
; Parameter......: $number - Eine beliebige natürliche Zahl
;				   $mode - Die gewünschte Fakultät:
;					|0: Normale Fakultät
;					|1: Primfakultät
;					|2: Superfakultät (Vorsicht! Rekursiver Aufruf!)
;					|3: Hyperfakultät
; Rückgabe.......: Erfolg - Gibt einen Integer zurück
;                  Fehler - Gibt False zurück, wenn $number oder $mode ungültig war
; Autor(en)......: Niko H. <ChaosKeks at autoit dot de>, Matthias Gianfelice <matthias at gianfelice dot de>
; ===============================================================================================================================
Func _MathEx_Factorial($number, $mode = 0)
	If Not _MathEx_IsNumber($number) Or $number < 1 Or $mode < 0 Or $mode > 3 Or Not IsInt($mode) Then Return False
	Local $number_mathex_temp = 1
	Switch $mode
		Case 0
			For $i = 1 To $number
				$number_mathex_temp *= $i
			Next
		Case 1
			If $number = 1 Then Return 0
			For $i = 2 To $number
				If _MathEx_IsPrime($i) Then $number_mathex_temp *= $i
			Next
		Case 2
			For $i = 1 To $number
				$number_mathex_temp *= _MathEx_Factorial($i)
			Next
		Case 3
			For $i = 1 To $number
				$number_mathex_temp *= $i ^ $i
			Next
	EndSwitch
	Return $number_mathex_temp
EndFunc   ;==>_MathEx_Factorial

; #FUNCTION# ====================================================================================================================
; Name...........: _MathEx_Eul
; Beschreibung...: Gibt die eulersche Zahl nach einer vorgegebenen Genauigkeit an
; Syntax.........: _MathEx_Eul([$accuracy = 65])
; Parameter......: $accuracy - Die Genauigkeit (Zahl sollte einschließlich zwischen 1 und 65 liegen)
; Rückgabe.......: Erfolg - Gibt die eurlersche Zahl zurück
;                  Fehler - Gibt -1 zurück, wenn $accuracy ungültig war
; Autor(en)......: Niko H. <ChaosKeks at autoit dot de>, Matthias Gianfelice <matthias at gianfelice dot de>
; ===============================================================================================================================
Func _MathEx_Eul($accuracy = 65)
	Local $number_mathex_eul = 1
	If Not IsInt($accuracy) Then Return -1
	If $accuracy < 1 Then $accuracy = 1
	If $accuracy > 65 Then $accuracy = 65
	For $i = 1 To $accuracy
		$number_mathex_eul += 1 / _MathEx_Factorial($i)
	Next
	Return $number_mathex_eul
EndFunc   ;==>_MathEx_Eul

; #FUNCTION# ====================================================================================================================
; Name...........: _MathEx_Point_Distance
; Beschreibung...: Ermittelt den Abstand zwischen zwei Punkten
; Syntax.........: _MathEx_Point_Distance($x1, $y1, $x2, $y2)
; Parameter......: $x1, $y1, $x2, $y2 - Die Koordinaten der Punkte
; Rückgabe.......: Erfolg - Gibt den Abstand zurück
;                  Fehler - Gibt -1 zurück, eine der Koordinaten ungültig war
; Autor(en)......: Matthias Gianfelice <matthias at gianfelice dot de>
; ===============================================================================================================================
Func _MathEx_Point_Distance($x1, $y1, $x2, $y2)
	If Not _MathEx_IsNumber($x1) Or Not _MathEx_IsNumber($y1) Or Not _MathEx_IsNumber($x2) Or Not _MathEx_IsNumber($y2) Then Return -1
	Return Sqrt(($x1 - $x2) ^ 2 + ($y1 - $y2) ^ 2)
EndFunc   ;==>_MathEx_Point_Distance

; #FUNCTION# ====================================================================================================================
; Name...........: _MathEx_Point_InRectangle
; Beschreibung...: Ermittelt den Abstand zwischen zwei Punkten
; Syntax.........: _MathEx_Point_InRectangle($P1, $P2, $X)
; Parameter......: $P1, $P2 - Arrays mit den Koordinaten des linken oberen Punktes ($P1) und des rechten unteren ($P2)
;				   $X - Koordinaten des zu prüfenden Punkts
;						=> [0] enthält die x-Koordinate und [1] die y-Koordinate der entsprechenden Punkte
; Rückgabe.......: Erfolg - Gibt 1 zurück, wenn sich der Punkt im, 0 wenn er sich auf dem Rand und -1 wenn er sich außerhalb
;							befindet
;                  Fehler - Gibt False zurück, wenn eine der Koordinaten ungültig war.
; Autor(en)......: Matthias Gianfelice <matthias at gianfelice dot de>
; ===============================================================================================================================
Func _MathEx_Point_InRectangle($P1, $P2, $X)
	If Not IsArray($P1) Or Not IsArray($P2) Or Not IsArray($X) Then Return False
	If Not _MathEx_IsNumber($P1[0]) Or Not _MathEx_IsNumber($P1[1]) Or Not _MathEx_IsNumber($P2[0]) Or Not _MathEx_IsNumber($P2[1]) Then Return False
	If Not _MathEx_IsNumber($X[0]) Or Not _MathEx_IsNumber($X[1]) Then Return False
	If $P1[0] > $P2[0] Or $P1[1] < $P2[1] Then Return False
	Select
		Case $X[0] > $P1[0] And $X[0] < $P2[0] And $X[1] < $P1[1] And $X[1] > $P2[1]
			Return 1
		Case $X[0] = $P1[0] And $X[1] <= $P1[1] And $X[1] >= $P2[1]
			Return 0
		Case $X[0] = $P2[0] And $X[1] <= $P1[1] And $X[1] >= $P2[1]
			Return 0
		Case $X[1] = $P1[1] And $X[0] >= $P1[0] And $X[0] <= $P2[0]
			Return 0
		Case $X[1] = $P2[1] And $X[0] >= $P1[0] And $X[0] <= $P2[0]
			Return 0
		Case Else
			Return -1
	EndSelect
EndFunc   ;==>_MathEx_Point_InRectangle

; #FUNCTION# ====================================================================================================================
; Name...........: _MathEx_GraphInfo
; Beschreibung...: Liefert Steigung und y-Achsenabschnitt eines Graphen zurück
; Syntax.........: _MathEx_GraphInfo($P1, $P2)
; Parameter......: $P1, $P2 - Arrays mit den Koordinaten zweier Punkte, die auf der Geraden liegen. $P2 muss einen größeren
;							  x-Wert als $P1 haben!
;						=> [0] enthält die x-Koordinate und [1] die y-Koordinate der entsprechenden Punkte
; Rückgabe.......: Erfolg - Gibt ein Array zurück, dass folgende Elemente enthält:
;						| [0] - Steigung
;						| [1] - y-Achsenabschnitt
;                  Fehler - Gibt False zurück, wenn eine der Koordinaten ungültig war.
; Autor(en)......: Matthias Gianfelice <matthias at gianfelice dot de>
; ===============================================================================================================================
Func _MathEx_GraphInfo($P1, $P2)
	If Not IsArray($P1) Or Not IsArray($P2) Then Return False
	If Not _MathEx_IsNumber($P1[0]) Or Not _MathEx_IsNumber($P1[1]) Or Not _MathEx_IsNumber($P2[0]) Or Not _MathEx_IsNumber($P2[1]) Then Return False
	If Not $P2[0] > $P1[0] Then Return False
	Local $array_mathex_return[2]
	$array_mathex_return[0] = ($P2[1] - $P1[1]) / ($P2[0] - $P1[0])
	$array_mathex_return[1] = $P1[1] - ($array_mathex_return[0] * $P1[0])
	Return $array_mathex_return
EndFunc   ;==>_MathEx_GraphInfo

; #FUNCTION# ====================================================================================================================
; Name...........: _MathEx_Point_OnLine
; Beschreibung...: Prüft, ob sich ein Punkt auf einer geraden befindet.
; Syntax.........: _MathEx_Point_OnLine($P1, $P2, $X)
; Parameter......: $P1, $P2 - Arrays mit den Koordinaten zweier auf der Geraden liegenden Punkte. $P2 muss einen größeren
;							  x-Wert als $P1 haben!
;				   $X - Koordinaten des zu prüfenden Punkts
;						=> [0] enthält die x-Koordinate und [1] die y-Koordinate der entsprechenden Punkte
; Rückgabe.......: Erfolg - Gibt 1 zurück, wenn sich der Punkt "über" der Geraden befindet, 0 wenn er sich auf der Geraden
;							befindet und -1 wenn er sich "unter" der geraden befindet
;                  Fehler - Gibt False zurück, wenn eine der Koordinaten ungültig war.
; Autor(en)......: Matthias Gianfelice <matthias at gianfelice dot de>
; ===============================================================================================================================
Func _MathEx_Point_OnLine($P1, $P2, $X)
	If Not IsArray($X) Then Return False
	Local $array_mathex_graphinfo = _MathEx_GraphInfo($P1, $P2)
	If $array_mathex_graphinfo == False Then Return False
	Local $number_mathex_term = $array_mathex_graphinfo[0] * $X[0] + $array_mathex_graphinfo[1]
	If $X[1] < $number_mathex_term Then
		Return -1
	ElseIf $X[1] > $number_mathex_term Then
		Return 1
	Else
		Return 0
	EndIf
EndFunc   ;==>_MathEx_Point_OnLine

; #FUNCTION# ====================================================================================================================
; Name...........: _MathEx_Point_OnSegment
; Beschreibung...: Prüft, ob sich ein Punkt auf einer Strecken befindet
; Syntax.........: _MathEx_Point_OnSegment($P1, $P2, $X)
; Parameter......: $P1, $P2 - Arrays mit den Koordinaten der zwei Endpunkte der Strecke. $P2 muss einen größeren x-Wert als $P1
;							  haben!
;				   $X - Koordinaten des zu prüfenden Punkts
;						=> [0] enthält die x-Koordinate und [1] die y-Koordinate der entsprechenden Punkte
; Rückgabe.......: Erfolg - Gibt 1 zurück, wenn sich der Punkt auf der Strecke befindet, 0 wenn nicht.
;                  Fehler - Gibt -1 zurück, wenn eine der Koordinaten ungültig war.
; Autor(en)......: Matthias Gianfelice <matthias at gianfelice dot de>
; ===============================================================================================================================
Func _MathEx_Point_OnSegment($P1, $P2, $X)
	$number_mathex_online = _MathEx_Point_OnLine($P1, $P2, $X)
	If $number_mathex_online == False Then Return -1
	If Not $number_mathex_online = 0 Then Return 0
	If $X[0] >= $P1[0] And $X[0] <= $P2[0] Then
		Return 1
	Else
		Return 0
	EndIf
EndFunc   ;==>_MathEx_Point_OnSegment