Beiträge von i2c

#Region - TimeStamp
; 2013-12-30 14:43:59 v 0.4
#EndRegion - TimeStamp

;----------------------------------------------------------------------------------------------------------------------
; Sammlung von Array-UDF
;
; Enthaltene Funktionen:
;
; _ArraySort_2ary() ==> [durch _Array2DSortFree() ersetzt]
; sortiert 2D Arrays mehrstufig
; !! Nicht entfernen: Wird von _Array2DSortByLen() verwendet
;
; _Array2DSortFree()
; sortiert 2D Arrays mehrstufig, jede Spalte kann in eigener Richtung sortiert werden
; ein bis alle Spalten sind ineinander sortierbar
; sortiert auch 1D-Arrays auf- oder absteigend
; Sortierung wahlweise alphabetisch oder numerisch
; !! Bemerkung:
; Die Funktion ist auskommentiert, da die verwendeten SQLite-Includes am Anfang des aufrufenden
; Skripts stehen müssen. Somit bringt jedes Include von 'ArrayMore.au3' in SciTE eine Fehlermeldung
; wegen der SQLite-Includes (auch wenn andere Funktionen genutzt werden prüft SciTE stets das ganze Include).
; Um diese Funktion zu verwenden, muß sie separat gespeichert und includiert oder direkt in das Skript
; kopiert werden.
;
; _Array2DSortByLen()
; sortiert 1D/2D Arrays nach Länge der Einträge
;
; _ArraySortDblDel() ** Funktion auskommentiert - siehe Funktionskopf
; sortiert 1D/2D Arrays und entfernt doppelte Einträge
; in 2.ter Dimension begrenzt auf 2 Vorkommen
;
; _Array2DDblDel()
; entfernt doppelte Einträge in 1D/2D Arrays
;
; _Array2DAdd()
; fügt einen Eintrag einem 1D/2D-Array hinzu
; Spaltenwerte in 2D-Arrays sind durch '|' zu trennen
; wird die Funktion ohne Wertübergabe aufgerufen, wird die Arraygröße um 1 erhöht
;
; _Array2DInsert()
; fügt 1 Element (leer oder mit Daten) an gegebener Position ein
; arbeitet mit 1D/2D Arrays
;
; _Array2DSplit()
; splittet 1D/2D Arrays ab gegebener Position in 2 Arrays
; optional wird eine Anzahl Elemente in ein Zielarray exportiert
;
; _Array2DEmptyDel()
; löscht leere Zeilen, in 2D Arrays Zeilen oder optional Spalten
;
; _Array2DJoin()
; verbindet 2 Arrays zu einem, 1D/2D -Arrays, auch untereinander
; Größe der 2.ten Dimension muß nicht übereinstimmen
;
; _Array2DDelete
; löscht eine Zeile oder Spalte aus einem (1D)2D -Array am gegebenen Index
;
; _Array2DSearch()
; sucht nach allen oder einmaligem Auftreten des Suchbegriffs in einem 1D/2D -Array
; ein Array mit dem/den gefundenen Index(es) wird zurückgeliefert
;
; _Array2DMirror()
; spiegelt ein 2D-Array, Zeilen werden zu Spalten und umgekehrt
;
; _SubArrayGetEntry()
; gibt den Wert eines Elements aus einem 1D/2D-Array als Element eines 1D/2D-Arrays zurück
;
; _SubArraySetEntry()
; setzt den Wert eines Elements in einem 1D/2D-Array als Element eines 1D/2D-Arrays
;
; _Array2DSortByCountSameEntries()
; sortiert ein Array nach der Anzahl gleicher Elemente, bei 2D für eine angegebene Spalte
;
; _Array2DPop()
; gibt den letzten Wert eines 1D/2D-Arrays zurück und löscht ihn gleichzeitig vom Array
;
; _Array2DPush()
; fügt Einzelwerte oder Arrays in 1D/2D-Arrays ein ohne deren Größe zu verändern
; es kann vom Anfang oder vom Ende eingefügt werden, überzählige Elemente werden 'herausgeschoben'
;
; _Array2DMinMax()
; gibt den minimalen od. maximalen Wert eines 1D/2D-Array zurück
; Überprüfung einer oder aller Spalten
;
;----------------------------------------------------------------------------------------------------------------------
#include-once
#include <Array.au3>
;----------------------------------------------------------------------------------------------------------------------
; Function _ArraySort_2ary(ByRef $ARRAY [, $DIM_1ST=0 [, $DESCENDING=0 [$REVERSE=False]]])
;
; Description sort an 2D-Array 2-ary
; BaseIndex is 0
; sort the whole array
;
; Parameter $ARRAY: Array to sort
; optional $DIM_1ST: MainSortIndex; 1st Dim. [0] or last occurence in 2nd Dim.[all other values] (default 0)
; optional $DESCENDING: Sort ascending[0]/descending[1] (default 0)
; optional $REVERSE: Sort 2nd Dimension reverse to 1st Dimension (default False)
;
; Return Succes 0 ByRef 2-ary sorted Array
; Failure 1 set @error
; @error = 1 given array is not array
; @error = 2 given array has only 1 dimension
;
; Requirements By using numeric entry, be sure that type is "number" for correct sort
; Works with any occurences in 2nd Dimension
;
; Author BugFix ([email='bugfix@autoit.de'][/email])
;----------------------------------------------------------------------------------------------------------------------
Func _ArraySort_2ary(ByRef $ARRAY, $DIM_1ST=0, $DESCENDING=0, $REVERSE=False)
If ( Not IsArray($ARRAY) ) Then Return SetError(1,0,1)
Local $FIRST = 0, $LAST, $arOutFIRST, $sortYES = 0, $u, $i
Local $UBound2nd = UBound($ARRAY,2)
If @error = 2 Then Return SetError(2,0,1)
If $DIM_1ST <> 0 Then $DIM_1ST = $UBound2nd-1
Local $arTmp[1][$UBound2nd]
_ArraySort($ARRAY,$DESCENDING,0,0,$DIM_1ST)
If $REVERSE Then
Switch $DESCENDING
Case 0
$DESCENDING = 1
Case 1
$DESCENDING = 0
EndSwitch
EndIf
For $u = 0 To $UBound2nd-1
For $i = 0 To UBound($ARRAY)-1
If $sortYES = 0 Then
If $u > 0 Then
If ( $i < UBound($ARRAY)-1 ) And ( $ARRAY[$i][$u] = $ARRAY[$i+1][$u] ) And _
( $ARRAY[$i][$u-1] = $ARRAY[$i+1][$u-1] )Then
$sortYES = 1
$FIRST = $i
EndIf
Else
If ( $i < UBound($ARRAY)-1 ) And ( $ARRAY[$i][$u] = $ARRAY[$i+1][$u] ) Then
$sortYES = 1
$FIRST = $i
EndIf
EndIf
ElseIf $sortYES = 1 Then
If ( $i = UBound($ARRAY)-1 ) Or ( $ARRAY[$i][$u] <> $ARRAY[$i+1][$u] ) Then
$sortYES = 0
$LAST = $i +1
ReDim $arTmp[$LAST-$FIRST][$UBound2nd]
$arOutFIRST = $FIRST
For $k = 0 To UBound($arTmp)-1
For $l = 0 To $UBound2nd-1
$arTmp[$k][$l] = $ARRAY[$arOutFIRST][$l]
Next
$arOutFIRST += 1
Next
$arOutFIRST = $FIRST
Switch $DIM_1ST
Case 0
If $u = $UBound2nd-1 Then
_ArraySort($arTmp,$DESCENDING,0,0,$UBound2nd-1)
Else
_ArraySort($arTmp,$DESCENDING,0,0,$u+1)
EndIf
For $k = 0 To UBound($arTmp)-1
For $l = 1 To $UBound2nd-1
$ARRAY[$arOutFIRST][$l] = $arTmp[$k][$l]
Next
$arOutFIRST += 1
Next
Case $UBound2nd-1
If $u = $UBound2nd-1 Then
_ArraySort($arTmp,$DESCENDING,0,0,0)
Else
_ArraySort($arTmp,$DESCENDING,0,0,$UBound2nd-1-$u-1)
EndIf
For $k = 0 To UBound($arTmp)-1
For $l = 0 To $UBound2nd-2
$ARRAY[$arOutFIRST][$l] = $arTmp[$k][$l]
Next
$arOutFIRST += 1
Next
EndSwitch
EndIf
EndIf
Next
$sortYES = 0
Next
Return 0
EndFunc ;==>_ArraySort_2ary
#cs s. Bemerkungen in Funktionsliste
;==================================================================================================
; Function Name: _Array2DSortFree($ARRAY, $sCOL_ASC [, $NUM=False])
; Description:: Sortierung von 1D/2D-Arrays nach freier Wahl
; 1D Sortierung Auf- oder Absteigend
; 2D mehrstufige Sortierung, Reihenfolge und Sortier-
; richtung (je Spalte) frei wählbar
; auch einzelne Spalte sortierbar
; Parameter(s): $ARRAY Das zu sortierende Array
; $sCOL_ASC String mit Sortierangaben "Spalte|Richtung [, Spalte|Richtung]"
; zu sortierende Spalte (0-Index)|Richtung (0-Asc, 1-Desc)
; z.B. Spalte 2 aufsteigend und in 2 absteigend Spalte 1
; _Array2DSortFree($ar2Sort, '1|0,0|1')
; optional $NUM "False" sortiert alphabetisch (Standard), "True" sortiert numerisch
; Return Value(s): Erfolg 0
; Fehler 1 Set Error 1 $ARRAY ist kein Array
; 2 1D-Array, aber Spaltenangabe für 2D
; 3 SQL-Fehler
; 4 Angaben für Spalte|Sortierrichtung fehlerhaft
; Requirements: #include <SQLite.au3>
; #include <SQLite.dll.au3>
; #include <Array.au3>
; Note: Es ist dringend erforderlich, die SQLite-Includes am Beginn des aufrufenden
; Skriptes auszuführen. Anderenfalls schlägt die Initialisierung der SQLite.dll
; durch _SQLite_Startup() fehl.
; Version: 3.2.12.0
; Author(s): BugFix ([email='bugfix@autoit.de'][/email])
;==================================================================================================
Func _Array2DSortFree(ByRef $ARRAY, $sCOL_ASC, $NUM=False)
If Not IsArray($ARRAY) Then Return SetError(1,0,1)
Local $tableStr = "CREATE TABLE tblTEST ("
Local $insertStr = '', $insertBase = "INSERT INTO tblTEST VALUES ("
Local $sortOrder = '', $sortStr = "SELECT * FROM tblTEST ORDER BY "
Local $hQuery, $aRow, $asc, $i, $k
$sCOL_ASC = StringStripWS($sCOL_ASC,
Local $ub2nd = UBound($ARRAY, 2)
If @error = 2 Then
If (StringLen($sCOL_ASC) > 3) Or (StringLeft($sCOL_ASC, 1) <> '0') Then Return SetError(2,0,1)
If StringRight($sCOL_ASC, 1) = 0 Then
_ArraySort($ARRAY)
Else
_ArraySort($ARRAY, 1)
EndIf
Return 0
Else
Local $aOut[UBound($ARRAY)][$ub2nd]
EndIf
_SQLite_Startup ()
If @error > 0 Then Return SetError(3,0,1)
$hSQL = _SQLite_Open ()
If @error > 0 Then
_SQLite_Shutdown ()
Return SetError(3,0,1)
EndIf
For $i = 0 To UBound($ARRAY, 2) -1
$tableStr &= "'field" & $i & "',"
Next
$tableStr = StringTrimRight($tableStr, 1) & ");"
For $i = 0 To UBound($ARRAY) -1
$insertStr &= $insertBase
For $k = 0 To UBound($ARRAY, 2) -1
$insertStr &= "'" & $ARRAY[$i][$k] & "',"
Next
$insertStr = StringTrimRight($insertStr, 1) & ");"
Next
If _SQLite_Exec ( $hSQL, $tableStr & $insertStr ) <> $SQLITE_OK Then
_SQLite_Shutdown ()
Return SetError(3,0,1)
EndIf
If StringInStr($sCOL_ASC, ',') Then
Local $aOrder = StringSplit($sCOL_ASC, ',')
For $i = 1 To UBound($aOrder) -1
If StringInStr($sCOL_ASC, '|') Then
Local $var = StringSplit($aOrder[$i], '|')
$asc = ' ASC'
If $var[2] = 1 Then $asc = ' DESC'
If $NUM Then
$sortOrder &= 'ABS(field' & $var[1] & ')' & $asc & ','
Else
$sortOrder &= 'field' & $var[1] & $asc & ','
EndIf
Else
_SQLite_Shutdown ()
Return SetError(4,0,1)
EndIf
Next
$sortOrder = StringTrimRight($sortOrder, 1) & ';'
Else
If (StringLen($sCOL_ASC) = 3) And (StringInStr($sCOL_ASC, '|')) Then
Local $var = StringSplit($sCOL_ASC, '|')
$asc = ' ASC'
If $var[2] = 1 Then $asc = ' DESC'
If $NUM Then
$sortOrder &= 'ABS(field' & $var[1] & ')' & $asc
Else
$sortOrder &= 'field' & $var[1] & $asc
EndIf
Else
_SQLite_Shutdown ()
Return SetError(4,0,1)
EndIf
EndIf
If _SQlite_Query (-1, $sortStr & $sortOrder, $hQuery) <> $SQLITE_OK Then
_SQLite_Shutdown ()
Return SetError(3,0,1)
EndIf
$i = 0
While _SQLite_FetchData ($hQuery, $aRow) = $SQLITE_OK
For $k = 0 To UBound($ARRAY,2) -1
$ARRAY[$i][$k] = $aRow[$k]
Next
$i += 1
WEnd
_SQLite_Exec ($hSQL, "DROP TABLE tblTEST;")
_SQLite_Close ()
_SQLite_Shutdown ()
Return 0
EndFunc ;==>_Array2DSortFree
#ce
;----------------------------------------------------------------------------------------------------------------------
; Function _Array2DSortByLen(ByRef $ARRAY [, $iDESCENDING=0])
;
; Description - Sorts an 1D/2D Array by Length.
; - BaseIndex is 0; sorts the whole array.
;
; Parameter $ARRAY: Array to sort
; optional $iDESCENDING: Sort ascending[0]/descending[1] (default 0)
;
; Return Succes 0 ByRef sorted Array by Length
; Failure 1 set @error = 1; no array
;
; Requirements Func _ArraySort_2ary()
; #include <array.au3>
;
; Author BugFix ([email='bugfix@autoit.de'][/email])
;----------------------------------------------------------------------------------------------------------------------
Func _Array2DSortByLen(ByRef $ARRAY, $iDESCENDING=0)
If ( Not IsArray($ARRAY) ) Then Return SetError(1,0,1)
If $iDESCENDING <> 0 Then $iDESCENDING = 1
Local $i, $k
Local $UBound2nd = UBound($ARRAY,2)
Local $arTmp[1] = ['']
If @error = 2 Then
ReDim $arTmp[UBound($ARRAY)][2]
For $i = 0 To UBound($ARRAY)-1
$arTmp[$i][0] = StringLen($ARRAY[$i])
$arTmp[$i][1] = $ARRAY[$i]
$ARRAY[$i] = ''
Next
_ArraySort($arTmp,$iDESCENDING,0,0,0)
For $i = 0 To UBound($arTmp)-1
$ARRAY[$i] = $arTmp[$i][1]
Next
Else
ReDim $arTmp[UBound($ARRAY)][$UBound2nd+1]
For $i = 0 To UBound($ARRAY)-1
For $k = 0 To $UBound2nd-1
$arTmp[$i][$k] = StringLen($ARRAY[$i][$k])
Next
$arTmp[$i][$UBound2nd] = $i
Next
_ArraySort_2ary($arTmp, 0, $iDESCENDING)
For $i = 0 To UBound($arTmp)-1
For $k = 0 To $UBound2nd-1
$arTmp[$i][$k] = $ARRAY[$arTmp[$i][$UBound2nd]][$k]
Next
Next
ReDim $arTmp[UBound($ARRAY)][$UBound2nd]
$ARRAY = $arTmp
EndIf
Return 0
EndFunc ;==>_ArraySortByLen

;----------------------------------------------------------------------------------------------------------------------
; Function _Array2DDblDel(ByRef $ARRAY [, $CASESENS=0])
;
; Description - From an 1D/2D Array will delete double entries (2D -> combination by '[n][0]' to '[n][x]').
; - Autodetection 1D/2D Array
; - By using string, you can choose case sensitivity.
;
; Parameter $ARRAY: Array to delete double
; optional $CASESENS: Case sensitivity off[0] or on[1] (default 0)
;
; Return Succes Count of doubles
; ByRef Array without doubles
; Failure 1 and set @error = 1; no array
;
; Author BugFix ([email='bugfix@autoit.de'][/email])
;----------------------------------------------------------------------------------------------------------------------
Func _Array2DDblDel(ByRef $ARRAY, $CASESENS=0)
Local $arTmp[1] = [''], $dbl = 0, $count = 0, $x, $l, $val, $valTmp, $i, $k, $sDelim = Chr(1)
If ( Not IsArray($ARRAY) ) Then Return SetError(1,0,1)
Local $Ubound2nd = UBound($ARRAY,2)
If @error = 2 Then
For $i = 0 To UBound($ARRAY)-1
$dbl = 0
For $k = 0 To UBound($arTmp)-1
Switch $CASESENS
Case 0
If $arTmp[$k] = $ARRAY[$i] Then
$dbl = 1
$count += 1
EndIf
Case 1
If $arTmp[$k] == $ARRAY[$i] Then
$dbl = 1
$count += 1
EndIf
EndSwitch
Next
If $dbl = 0 Then
If $arTmp[0] = "" Then
$arTmp[0] = $ARRAY[$i]
Else
ReDim $arTmp[UBound($arTmp)+1]
$arTmp[UBound($arTmp)-1] = $ARRAY[$i]
EndIf
Else
$dbl = 0
EndIf
Next
Else
ReDim $arTmp[UBound($ARRAY)][$Ubound2nd]
Local $indexNew = -1
For $i = 0 To UBound($ARRAY)-1
$dbl = 0
$val = ''
$valTmp = ''
For $l = 0 To $Ubound2nd-1
$val &= $ARRAY[$i][$l] & $sDelim
Next
If $indexNew > -1 Then
For $k = 0 To $indexNew
For $l = 0 To $Ubound2nd-1
$valTmp &= $arTmp[$k][$l] & $sDelim
Next
Switch $CASESENS
Case 0
If $valTmp = $val Then
$dbl = 1
$count += 1
EndIf
Case 1
If $valTmp == $val Then
$dbl = 1
$count += 1
EndIf
EndSwitch
$valTmp = ''
Next
EndIf
If $dbl = 0 Then
$indexNew += 1
For $l = 0 To $Ubound2nd-1
$arTmp[$indexNew][$l] = $ARRAY[$i][$l]
Next
Else
$dbl = 0
EndIf
Next
ReDim $arTmp[$indexNew+1][$Ubound2nd]
EndIf
$ARRAY = $arTmp
Return $count
EndFunc ; ==>_ArrayDblDel

;------------------------------------------------------------------------------------------------------------
;
; Function _Array2DAdd(ByRef $avArray, $sValue='')
;
; Description Redim Array Size and add an Array element at last position
; Works with any occurences in 2nd Dimension
; Works also with 1D-Array
;
; Parameter $avArray Given Array
; optional $sValue Value of new Element, parts must be seperate with '|'
;
; Return Succes 0
; Failure 1 and set @error
; @error = 1 given array is not array
; @error = 2 given parts of Element too less/much
;
; Author BugFix ([email='bugfix@autoit.de'][/email])
;------------------------------------------------------------------------------------------------------------
Func _Array2DAdd(ByRef $avArray, $sValue='')
If ( Not IsArray($avArray) ) Then Return SetError(1,0,1)
Local $UBound2nd = UBound($avArray,2)
If @error = 2 Then
ReDim $avArray[UBound($avArray)+1]
$avArray[UBound($avArray)-1] = $sValue
Else
Local $arValue
ReDim $avArray[UBound($avArray)+1][$UBound2nd]
If $sValue = '' Then
For $i = 0 To $UBound2nd-2
$sValue &= '|'
Next
EndIf
$arValue = StringSplit($sValue, '|')
If $arValue[0] <> $UBound2nd Then
SetError(2)
Return 0
EndIf
For $i = 0 To $UBound2nd-1
$avArray[UBound($avArray)-1][$i] = $arValue[$i+1]
Next
EndIf
Return 0
EndFunc ;==>_Array2DAdd

;------------------------------------------------------------------------------------------------------------
;
; Function _Array2DInsert(ByRef $avArray, $iElement [, $sValue=''])
;
; Description Insert an Array element on a given position
; Works with any occurences in 2nd Dimension
; Works also with 1D-Array
;
; Parameter $avArray Given Array
; $iElement 0-based Array Index, to insert new Element
; optional $sValue Value of new Element, parts must be seperate with '|'
;
; Return Succes 0
; Failure 1 set @error
; @error = 1 given array is not array
; @error = 2 given parts of Element too less/much
; @error = 3 $iElement larger then Ubound
;
; Author BugFix ([email='bugfix@autoit.de'][/email])
;------------------------------------------------------------------------------------------------------------
Func _Array2DInsert(ByRef $avArray, $iElement, $sValue='')
If ( Not IsArray($avArray) ) Then Return SetError(1,0,1)
Local $UBound2nd = UBound($avArray,2)
If @error = 2 Then
Local $arTMP[UBound($avArray)+1]
If $iElement > UBound($avArray) Then Return SetError(3,0,1)
For $i = 0 To UBound($arTMP)-1
If $i < $iElement Then
$arTMP[$i] = $avArray[$i]
ElseIf $i = $iElement Then
If $i < UBound($avArray) Then
$arTMP[$i] = $sValue
$arTMP[$i+1] = $avArray[$i]
Else
$arTMP[$i] = $sValue
EndIf
ElseIf ($i > $iElement) And ($i < UBound($avArray))Then
$arTMP[$i+1] = $avArray[$i]
EndIf
Next
Else
Local $arTMP[UBound($avArray)+1][$UBound2nd], $arValue
If $sValue = '' Then
For $i = 0 To $UBound2nd-2
$sValue &= '|'
Next
EndIf
$arValue = StringSplit($sValue, '|')
If $arValue[0] <> $UBound2nd Then Return SetError(2,0,1)
If $iElement > UBound($avArray) Then Return SetError(3,0,1)
For $i = 0 To UBound($arTMP)-1
If $i < $iElement Then
For $k = 0 To $UBound2nd-1
$arTMP[$i][$k] = $avArray[$i][$k]
Next
ElseIf $i = $iElement Then
If $i < UBound($avArray) Then
For $k = 0 To $UBound2nd-1
$arTMP[$i][$k] = $arValue[$k+1]
$arTMP[$i+1][$k] = $avArray[$i][$k]
Next
Else
For $k = 0 To $UBound2nd-1
$arTMP[$i][$k] = $arValue[$k+1]
Next
EndIf
ElseIf ($i > $iElement) And ($i < UBound($avArray))Then
For $k = 0 To $UBound2nd-1
$arTMP[$i+1][$k] = $avArray[$i][$k]
Next
EndIf
Next
EndIf
$avArray = $arTMP
Return 0
EndFunc ;==>_Array2DInsert

;------------------------------------------------------------------------------------------------------------
; Funktion _Array2DSplit(ByRef $AR_SOURCE, ByRef $AR_TARGET, $iFROM=-1 [, $ANZ=-1])
;
; Beschreibung Splittet ein 1D/2D Array ab Indexposition, optional wird Anzahl Einträge ausgelagert
;
; Parameter $AR_SOURCE Array mit Ausgangsdaten
; $AR_TARGET Array mit abgesplitteten Daten
; $iFROM Index ab dem gesplittet wird
; optional $ANZ Anzahl Elemente, die abgesplittet werden sollen
;
; Rückgabe Erfolg 0
; Fehler 1 @error = 1 Ausgangsvariablen sind keine Arrays
; @error = 2 kein Startindex oder Index außerhalb Bereich
;
; Autor BugFix ([email='bugfix@autoit.de'][/email])
;------------------------------------------------------------------------------------------------------------
Func _Array2DSplit(ByRef $AR_SOURCE, ByRef $AR_TARGET, $iFROM=-1, $ANZ=-1)
If ( Not IsArray($AR_SOURCE) ) Or ( Not IsArray($AR_TARGET) ) Then Return SetError(1,0,1)
If $ANZ = -1 Then $ANZ = UBound($AR_SOURCE)-$iFROM
If ( $iFROM < 0 ) Or ( $iFROM > UBound($AR_SOURCE)-1 ) Or ( $ANZ < 1 ) Or ( $ANZ > (UBound($AR_SOURCE)-$iFROM) ) Then Return SetError(2,0,1)
Local $i, $j, $k
Local $UBound2nd = UBound($AR_SOURCE,2)
If @error = 2 Then
Local $arTMP[UBound($AR_SOURCE)-$ANZ]
ReDim $AR_TARGET[$ANZ]
For $k = 0 To $iFROM-1
$arTMP[$k] = $AR_SOURCE[$k]
Next
$j = 0
For $i = $iFROM To $iFROM+$ANZ-1
$AR_TARGET[$j] = $AR_SOURCE[$i]
$j += 1
Next
For $i = $iFROM+$ANZ To UBound($AR_SOURCE)-1
$arTMP[$k] = $AR_SOURCE[$i]
$k +=1
Next
$AR_SOURCE = $arTMP
Return 0
Else
Local $arTMP[UBound($AR_SOURCE)-$ANZ][$UBound2nd]
ReDim $AR_TARGET[$ANZ][$UBound2nd]
For $k = 0 To $iFROM-1
For $i = 0 To $UBound2nd-1
$arTMP[$k][$i] = $AR_SOURCE[$k][$i]
Next
Next
$j = 0
For $i = $iFROM To $iFROM+$ANZ-1
For $l = 0 To $UBound2nd-1
$AR_TARGET[$j][$l] = $AR_SOURCE[$i][$l]
Next
$j += 1
Next
For $i = $iFROM+$ANZ To UBound($AR_SOURCE)-1
For $l = 0 To $UBound2nd-1
$arTMP[$k][$l] = $AR_SOURCE[$i][$l]
Next
$k +=1
Next
$AR_SOURCE = $arTMP
Return 0
EndIf
EndFunc ;==>_Array2DSplit

;----------------------------------------------------------------------------------------------------------------------
; Function _Array2DEmptyDel(ByRef $avArray [, $Col=0])
;
; Description Delete empty Array elements
; Delete all emty Rows or all empty Columns
; Works also with 1D-Array (only Rows)
;
; Parameter $avArray Given Array
; optional $Col set 1 to delete empty Columns; default is 0 to delete empty Rows
;
; Return Succes 0 ByRef the given Array without empty Elements, resized
; Failure 1 and set @error = 1
;
; Author BugFix ([email='bugfix@autoit.de'][/email])
;----------------------------------------------------------------------------------------------------------------------
Func _Array2DEmptyDel(ByRef $avArray, $Col=0)
If ( Not IsArray($avArray) ) Then Return SetError(1,0,1)
Local $i, $k, $notEmpty
Local $UBound2nd = UBound($avArray,2)
If @error = 2 Then
Local $arTMP[UBound($avArray)], $indexNew = -1
For $i = 0 To UBound($avArray)-1
If $avArray[$i] <> '' Then
$indexNew += 1
$arTMP[$indexNew] = $avArray[$i]
EndIf
Next
ReDim $arTMP[$indexNew+1]
Else
If $Col = 0 Then
Local $arTMP[1][$UBound2nd], $val, $len
For $i = 0 To UBound($avArray)-1
$val = ''
For $k = 0 To $UBound2nd-1
$val &= $avArray[$i][$k]
Next
If $val <> 0 Then
$len = 0
For $k = 0 To UBound($arTMP,2)-1
$len &= StringLen($arTMP[UBound($arTMP)-1][$k])
Next
If $len = 0 Then
For $k = 0 To $UBound2nd-1
$arTMP[UBound($arTMP)-1][$k] = $avArray[$i][$k]
Next
Else
ReDim $arTMP[UBound($arTMP)+1][$UBound2nd]
For $k = 0 To $UBound2nd-1
$arTMP[UBound($arTMP)-1][$k] = $avArray[$i][$k]
Next
EndIf
EndIf
Next
Else
Local $arTMP[UBound($avArray)][1], $val, $len
For $k = 0 To $UBound2nd-1
$val = ''
$notEmpty = 0
For $i = 0 To UBound($avArray)-1
$val &= $avArray[$i][$k]
If $val <> '' Then
$notEmpty = 1
ExitLoop
EndIf
Next
If $notEmpty = 1 Then
$len = 0
For $i = 0 To UBound($arTMP)-1
$len &= StringLen($arTMP[$i][UBound($arTMP,2)-1])
Next
If $len = 0 Then
For $i = 0 To UBound($avArray)-1
$arTMP[$i][0] = $avArray[$i][$k]
Next
Else
ReDim $arTMP[UBound($avArray)][UBound($arTMP,2)+1]
For $i = 0 To UBound($avArray)-1
$arTMP[$i][UBound($arTMP,2)-1] = $avArray[$i][$k]
Next
EndIf
EndIf
Next
EndIf
EndIf
$avArray = $arTMP
Return 0
EndFunc ;==>_Array2DEmptyDel

;----------------------------------------------------------------------------------------------------------------------
; Fuction _Array2DJoin(ByRef $ARRAY, ByRef $AR2JOIN)
;
; Description Join 2 Arrays, 1D/2D can be mixed
;
; Parameter $ARRAY 1st array, will be joined with 2nd
; $AR2JOIN 2nd array
;
; Return Succes 0 ByRef $ARRAY
; Failure 1 set @error = 1; given array(s) are not array
;
; Author BugFix ([email='bugfix@autoit.de'][/email])
;----------------------------------------------------------------------------------------------------------------------
Func _Array2DJoin(ByRef $ARRAY, ByRef $AR2JOIN)
If ( Not IsArray($ARRAY) ) Or ( Not IsArray($AR2JOIN) ) Then Return SetError(1,0,1)
Local $UB2ndAR = UBound($ARRAY,2), $i, $k
If @error = 2 Then $UB2ndAR = 0
Local $UB2nd2JOIN = UBound($AR2JOIN,2)
If @error = 2 Then $UB2nd2JOIN = 0
Select
Case $UB2ndAR = 0 And $UB2nd2JOIN = 0
For $i = 0 To UBound($AR2JOIN)-1
ReDim $ARRAY[UBound($ARRAY)+1]
$ARRAY[UBound($ARRAY)-1] = $AR2JOIN[$i]
Next
Return -1
Case $UB2ndAR > 0 And $UB2nd2JOIN = 0
Local $arTmp = $AR2JOIN
ReDim $AR2JOIN[UBound($AR2JOIN)][$UB2ndAR]
For $i = 0 To UBound($arTmp)-1
$AR2JOIN[$i][0] = $arTmp[$i]
Next
Case $UB2ndAR = 0 And $UB2nd2JOIN > 0
Local $arTmp = $ARRAY
ReDim $ARRAY[UBound($ARRAY)][$UB2nd2JOIN]
For $i = 0 To UBound($arTmp)-1
$ARRAY[$i][0] = $arTmp[$i]
Next
Case $UB2ndAR > 0 And $UB2nd2JOIN > 0
Select
Case $UB2ndAR < $UB2nd2JOIN
ReDim $ARRAY[UBound($ARRAY)][$UB2nd2JOIN]
Case $UB2ndAR > $UB2nd2JOIN
ReDim $AR2JOIN[UBound($AR2JOIN)][$UB2ndAR]
EndSelect
EndSelect
For $i = 0 To UBound($AR2JOIN)-1
ReDim $ARRAY[UBound($ARRAY)+1][UBound($ARRAY,2)]
For $k = 0 To UBound($AR2JOIN,2)-1
$ARRAY[UBound($ARRAY)-1][$k] = $AR2JOIN[$i][$k]
Next
Next
Return 0
EndFunc ;==>_Array2DJoin

;----------------------------------------------------------------------------------------------------------------------
; Fuction _Array2DDelete(ByRef $ARRAY, $iDEL, $bCOL=False)
;
; Description Delete one row on a given index in an 1D/2D -Array
;
; Parameter $ARRAY the array, where one row will deleted
; $iDEL Row(Column)-Index to delete
; $bCOL If True, delete column instead of row (default False)
;
; Return Succes 0 ByRef $ARRAY
; Failure 1 set @error = 1; given array are not array
; set @error = 2; want delete column, but not 2D-array
; set @error = 3; index is out of range
;
; Author BugFix ([email='bugfix@autoit.de'][/email])
;----------------------------------------------------------------------------------------------------------------------
Func _Array2DDelete(ByRef $ARRAY, $iDEL, $bCOL=False)
If ( Not IsArray($ARRAY) ) Then Return SetError(1,0,1)
Local $UBound2nd = UBound($ARRAY,2), $k
If $bCOL Then
If $UBound2nd = 0 Then Return SetError(2,0,1)
If ( $iDEL < 0 ) Or ( $iDEL > $UBound2nd-1 ) Then Return SetError(3,0,1)
Else
If ( $iDEL < 0 ) Or ( $iDEL > UBound($ARRAY)-1 ) Then Return SetError(3,0,1)
EndIf
If $UBound2nd = 0 Then
Local $arTmp[UBound($ARRAY)-1]
$k = 0
For $i = 0 To UBound($ARRAY)-1
If $i <> $iDEL Then
$arTmp[$k] = $ARRAY[$i]
$k += 1
EndIf
Next
Else
If $bCOL Then
Local $arTmp[UBound($ARRAY)][$UBound2nd-1]
For $i = 0 To UBound($ARRAY)-1
$k = 0
For $l = 0 To $UBound2nd-1
If $l <> $iDEL Then
$arTmp[$i][$k] = $ARRAY[$i][$l]
$k += 1
EndIf
Next
Next
Else
Local $arTmp[UBound($ARRAY)-1][$UBound2nd]
$k = 0
For $i = 0 To UBound($ARRAY)-1
If $i <> $iDEL Then
For $l = 0 To $UBound2nd-1
$arTmp[$k][$l] = $ARRAY[$i][$l]
Next
$k += 1
EndIf
Next
EndIf
EndIf
$ARRAY = $arTmp
Return 0
EndFunc ;==>_Array2DDelete

;----------------------------------------------------------------------------------------------------------------------
;
; Function _Array2DSearch(ByRef $avArray, $vWhat2Find [, $iDim=-1 [, $iStart=0 [, $iEnd=0 [, $iCaseSense=0 [, $fPartialSearch=False [, $1stFound=False]]]]]])
;
; Description Finds all Entry's like $vWhat2Find in an 1D/2D Array
; Works with all occurences in 2nd Dimension
; Search in all occurences or only in a given column
; To set numeric values for default, you can use -1
;
; Parameter $avArray The array to search
; $vWhat2Find What to search $avArray for
; optional $iDim Index of Dimension to search; default -1 (all)
; optional $iStart Start array index for search; default 0
; optional $iEnd End array index for search; default 0
; optional $iCaseSense If set to 1 then search is case sensitive; default 0
; optional $fPartialSearch If set to True then executes a partial search. default False
; optional $1stFound If set to True, only one match will be searched; default False
;
; Return Succes Array with Index of matches, Array[0] includes the count of matches
; In an 2D Array you got for every match [iRow|iCol]
; Array[0] = 0 if no element found
; If option 1stFound is set, Array[0] = FoundIndex; if no element found Array[0] = -1
; Failure 1 and set @error
; @error = 1 given array is not array
; @error = 2 given dim is out of range
; @error = 4 $iStart is out of range
; @error = 8 $iEnd is out of range
;
; Author BugFix ([email='bugfix@autoit.de'][/email])
;----------------------------------------------------------------------------------------------------------------------
Func _Array2DSearch(ByRef $avArray, $vWhat2Find, $iDim=-1, $iStart=0, $iEnd=0, $iCaseSense=0, $fPartialSearch=False, $1stFound=False)
Local $error = 0, $1D, $arFound[1]=[0], $i, $k
If $1stFound Then $arFound[0] = -1
If ( Not IsArray($avArray) ) Then Return SetError(1,0,1)
Local $UBound2nd = UBound($avArray,2)
If @error = 2 Then $1D = True
If ( $iEnd = 0 ) Or ( $iEnd = -1 ) Then $iEnd = UBound($avArray)-1
If $iStart = -1 Then $iStart = 0
If $iCaseSense = -1 Then $iCaseSense = 0
If $iCaseSense <> 0 Then $iCaseSense = 1
Select
Case ( $iDim > $UBound2nd ) Or ( $iDim < -1 )
$error += 2
Case ( $iStart < 0 ) Or ( $iStart > UBound($avArray)-1 )
$error += 4
Case ( $iEnd < $iStart ) Or ( $iEnd > UBound($avArray)-1 )
$error += 8
EndSelect
If $error <> 0 Then Return SetError($error,0,1)
If $fPartialSearch <> True Then $fPartialSearch = False
If $1D Then
For $i = $iStart To $iEnd
Select
Case $iCaseSense = 0 And (Not $fPartialSearch)
If $avArray[$i] = $vWhat2Find Then
If $1stFound Then
$arFound[0] = $i
Return $arFound
Else
ReDim $arFound[UBound($arFound)+1]
$arFound[UBound($arFound)-1] = $i
$arFound[0] += 1
EndIf
EndIf
Case $iCaseSense = 1 And (Not $fPartialSearch)
If $avArray[$i] == $vWhat2Find Then
If $1stFound Then
$arFound[0] = $i
Return $arFound
Else
ReDim $arFound[UBound($arFound)+1]
$arFound[UBound($arFound)-1] = $i
$arFound[0] += 1
EndIf
EndIf
Case $iCaseSense = 0 And $fPartialSearch
If StringInStr($avArray[$i], $vWhat2Find) Then
If $1stFound Then
$arFound[0] = $i
Return $arFound
Else
ReDim $arFound[UBound($arFound)+1]
$arFound[UBound($arFound)-1] = $i
$arFound[0] += 1
EndIf
EndIf
Case $iCaseSense = 1 And $fPartialSearch
If StringInStr($avArray[$i], $vWhat2Find, 1) Then
If $1stFound Then
$arFound[0] = $i
Return $arFound
Else
ReDim $arFound[UBound($arFound)+1]
$arFound[UBound($arFound)-1] = $i
$arFound[0] += 1
EndIf
EndIf
EndSelect
Next
Else
For $i = $iStart To $iEnd
If $iDim = -1 Then
Select
Case $iCaseSense = 0 And (Not $fPartialSearch)
For $k = 0 To $UBound2nd-1
If $avArray[$i][$k] = $vWhat2Find Then
If $1stFound Then
$arFound[0] = $i & '|' & $k
Return $arFound
Else
ReDim $arFound[UBound($arFound)+1]
$arFound[UBound($arFound)-1] = $i & '|' & $k
$arFound[0] += 1
EndIf
EndIf
Next
Case $iCaseSense = 1 And (Not $fPartialSearch)
For $k = 0 To $UBound2nd-1
If $avArray[$i][$k] == $vWhat2Find Then
If $1stFound Then
$arFound[0] = $i & '|' & $k
Return $arFound
Else
ReDim $arFound[UBound($arFound)+1]
$arFound[UBound($arFound)-1] = $i & '|' & $k
$arFound[0] += 1
EndIf
EndIf
Next
Case $iCaseSense = 0 And $fPartialSearch
For $k = 0 To $UBound2nd-1
If StringInStr($avArray[$i][$k], $vWhat2Find) Then
If $1stFound Then
$arFound[0] = $i & '|' & $k
Return $arFound
Else
ReDim $arFound[UBound($arFound)+1]
$arFound[UBound($arFound)-1] = $i & '|' & $k
$arFound[0] += 1
EndIf
EndIf
Next
Case $iCaseSense = 1 And $fPartialSearch
For $k = 0 To $UBound2nd-1
If StringInStr($avArray[$i][$k], $vWhat2Find, 1) Then
If $1stFound Then
$arFound[0] = $i & '|' & $k
Return $arFound
Else
ReDim $arFound[UBound($arFound)+1]
$arFound[UBound($arFound)-1] = $i & '|' & $k
$arFound[0] += 1
EndIf
EndIf
Next
EndSelect
Else
Select
Case $iCaseSense = 0 And (Not $fPartialSearch)
If $avArray[$i][$iDim] = $vWhat2Find Then
If $1stFound Then
$arFound[0] = $i & '|' & $iDim
Return $arFound
Else
ReDim $arFound[UBound($arFound)+1]
$arFound[UBound($arFound)-1] = $i & '|' & $iDim
$arFound[0] += 1
EndIf
EndIf
Case $iCaseSense = 1 And (Not $fPartialSearch)
If $avArray[$i][$iDim] == $vWhat2Find Then
If $1stFound Then
$arFound[0] = $i & '|' & $iDim
Return $arFound
Else
ReDim $arFound[UBound($arFound)+1]
$arFound[UBound($arFound)-1] = $i & '|' & $iDim
$arFound[0] += 1
EndIf
EndIf
Case $iCaseSense = 0 And $fPartialSearch
If StringInStr($avArray[$i][$iDim], $vWhat2Find) Then
If $1stFound Then
$arFound[0] = $i & '|' & $iDim
Return $arFound
Else
ReDim $arFound[UBound($arFound)+1]
$arFound[UBound($arFound)-1] = $i & '|' & $iDim
$arFound[0] += 1
EndIf
EndIf
Case $iCaseSense = 1 And $fPartialSearch
If StringInStr($avArray[$i][$iDim], $vWhat2Find, 1) Then
If $1stFound Then
$arFound[0] = $i & '|' & $iDim
Return $arFound
Else
ReDim $arFound[UBound($arFound)+1]
$arFound[UBound($arFound)-1] = $i & '|' & $iDim
$arFound[0] += 1
EndIf
EndIf
EndSelect
EndIf
Next
EndIf
Return $arFound
EndFunc ;==>_Array2DSearch

;----------------------------------------------------------------------------------------------------------------------
; Function _Array2DMirror(ByRef $ARRAY)
;
; Description In an array will mirrored rows and columns.
; Row will be column and contrary.
; Works with any occurences in 2nd Dimension (parent array)
;
; Parameter $ARRAY 2D-Array
;
; Return Succes 0 rows and columns are mirrored
; Failure 1 and set @error
; @error = 1 given array is not array
; @error = 2 given array has'nt 2 dimensions
;
; Author BugFix ([email='bugfix@autoit.de'][/email])
;----------------------------------------------------------------------------------------------------------------------
Func _Array2DMirror(ByRef $ARRAY)
If ( Not IsArray($ARRAY) ) Then Return SetError(1,0,1)
Local $i, $k
Local $UBound2nd = UBound($ARRAY,2)
If @error = 2 Then Return SetError(2,0,1)
Local $arTMP[$UBound2nd][UBound($ARRAY)]
For $i = 0 To UBound($ARRAY) -1
For $k = 0 To UBound($ARRAY,2) -1
$arTMP[$k][$i] = $ARRAY[$i][$k]
Next
Next
$ARRAY = $arTMP
Return 0
EndFunc ;==>_Array2DMirror

;----------------------------------------------------------------------------------------------------------------------
; Function _SubArray2DGetEntry(ByRef $ARRAY, $SubRow, $ParentRow [, $SubCol=-1 [, $ParentCol=-1])
;
; Description For Array with Array as entry you got the determined entry
; Works with any occurences in 2nd Dimension (parent array and sub-array too)
; Works also with 1D-Array
;
; Parameter $ARRAY Given array with array as entrys
; $SubRow 0-based row -index of the entry inside the sub-array, you want to got
; $ParentRow 0-based row -index of parent-array
; optional $SubCol 0-based column -index of sub-array, (if exists)
; optional $ParentCol 0-based column -index of parent-array, (if exists)
;
; Return Succes value from determined sub-array
; Failure 1 and set @error
; @error = 1 given array is not array
; @error = 2 row -index for parent-array out of range
; @error = 3 col -index for parent-array out of range
; @error = 4 col -index for parent-array is given, but array is 1D
; @error = 5 row -index for sub-array out of range
; @error = 6 col -index for sub-array out of range
; @error = 7 col -index for sub-array is given, but array is 1D
;
; Author BugFix ([email='bugfix@autoit.de'][/email])
;----------------------------------------------------------------------------------------------------------------------
Func _SubArray2DGetEntry(ByRef $ARRAY, $SubRow, $ParentRow, $SubCol=-1, $ParentCol=-1)
If (Not IsArray($ARRAY)) Then Return SetError(1,0,1)
If ($ParentRow < 0) Or ($ParentRow > UBound($ARRAY)-1) Then Return SetError(2,0,1)
Local $Ub2ndParent = UBound($ARRAY, 2)
If @error Then
If $ParentCol <> -1 Then Return SetError(4,0,1)
ElseIf ($ParentCol < -1) Or ($ParentCol > $Ub2ndParent-1) Then
Return SetError(3,0,1)
EndIf
Switch $ParentCol
Case -1
Local $arSub = $ARRAY[$ParentRow]
Case Else
Local $arSub = $ARRAY[$ParentRow][$ParentCol]
EndSwitch
If ($SubRow < 0) Or ($SubRow > UBound($arSub)-1) Then Return SetError(5,0,1)
Local $Ub2ndSub = UBound($arSub, 2)
If @error Then
If $SubCol <> -1 Then
Return SetError(7,0,1)
Else
Return $arSub[$SubRow]
EndIf
Else
If ($SubCol < 0) Or ($SubCol > $Ub2ndSub) Then
Return SetError(6,0,1)
Else
Return $arSub[$SubRow][$SubCol]
EndIf
EndIf
EndFunc ;==>_SubArray2DGetEntry

;----------------------------------------------------------------------------------------------------------------------
; Function _SubArray2DSetEntry(ByRef $ARRAY, $Entry, $SubRow, $ParentRow [, $SubCol=-1 [, $ParentCol=-1])
;
; Description For Array with Array as entry you set the determined entry
; Works with any occurences in 2nd Dimension (parent array and sub-array too)
; Works also with 1D-Array
;
; Parameter $ARRAY Given array with array as entrys
; $Entry Value you want to set in the sub-array
; $SubRow 0-based row -index of the entry inside the sub-array, you want to set
; $ParentRow 0-based row -index of parent-array
; optional $SubCol 0-based column -index of sub-array, (if exists)
; optional $ParentCol 0-based column -index of parent-array, (if exists)
;
; Return Succes 0 value is set
; Failure 1 and set @error
; @error = 1 given array is not array
; @error = 2 row -index for parent-array out of range
; @error = 3 col -index for parent-array out of range
; @error = 4 col -index for parent-array is given, but array is 1D
; @error = 5 row -index for sub-array out of range
; @error = 6 col -index for sub-array out of range
; @error = 7 col -index for sub-array is given, but array is 1D
;
; Author BugFix ([email='bugfix@autoit.de'][/email])
;----------------------------------------------------------------------------------------------------------------------
Func _SubArray2DSetEntry(ByRef $ARRAY, $Entry, $SubRow, $ParentRow, $SubCol=-1, $ParentCol=-1)
If (Not IsArray($ARRAY)) Then Return SetError(1,0,1)
If ($ParentRow < 0) Or ($ParentRow > UBound($ARRAY)-1) Then Return SetError(2,0,1)
Local $Ub2ndParent = UBound($ARRAY, 2)
If @error Then
If $ParentCol <> -1 Then Return SetError(4,0,1)
ElseIf ($ParentCol < -1) Or ($ParentCol > $Ub2ndParent-1) Then
Return SetError(3,0,1)
EndIf
Switch $ParentCol
Case -1
Local $arSub = $ARRAY[$ParentRow]
Case Else
Local $arSub = $ARRAY[$ParentRow][$ParentCol]
EndSwitch
If ($SubRow < 0) Or ($SubRow > UBound($arSub)-1) Then Return SetError(5,0,1)
Local $Ub2ndSub = UBound($arSub, 2)
If @error Then
If $SubCol <> -1 Then
Return SetError(7,0,1)
Else
$arSub[$SubRow] = $Entry
EndIf
Else
If ($SubCol < 0) Or ($SubCol > $Ub2ndSub) Then
Return SetError(6,0,1)
Else
$arSub[$SubRow][$SubCol] = $Entry
EndIf
EndIf
Switch $ParentCol
Case -1
$ARRAY[$ParentRow] = $arSub
Case Else
$ARRAY[$ParentRow][$ParentCol] = $arSub
EndSwitch
Return 0
EndFunc ;==>_SubArray2DSetEntry

;----------------------------------------------------------------------------------------------------------------------
; Function _Array2DSortByCountSameEntries(ByRef $ARRAY [, $iCol=0 [, $DESCENDING=1]])
;
; Description - Sorts an 1D/2D Array by count of same entries (2D - in a given column)
; - Count de- or ascending
;
; Parameter $ARRAY: Array to sort
; optional $iCol: Column with same entries to sort (default 0)
; optional $DESCENDING: Sort ascending[0]/descending[1] (default 1)
;
; Return Success 0 sorted array
; Failure 1 @error = 1, given array is not array
;
; Requirements _ArraySort_2ary() with #include <array.au3>
;
; Author BugFix ([email='bugfix@autoit.de'][/email])
;----------------------------------------------------------------------------------------------------------------------
Func _Array2DSortByCountSameEntries(ByRef $ARRAY, $iCol=0, $DESCENDING=1)
If ( Not IsArray($ARRAY) ) Then Return SetError(1,0,1)
If $DESCENDING <> 1 Then $DESCENDING = 0
Local $UBound2nd = UBound($ARRAY,2)
If @error = 2 Then
Dim $aTMP[UBound($ARRAY)][2]
For $i = 0 To UBound($ARRAY)-1
$aTMP[$i][0] = 1
$aTMP[$i][1] = $ARRAY[$i]
Next
$k = 0
For $i = 0 To UBound($ARRAY)-1
If ($i > 0) And ($i < UBound($ARRAY)-1) Then
If $ARRAY[$i] <> $aTMP[$k][1] Then
For $x = $k To $i-1
$aTMP[$x][0] = $i-$k
Next
$k = $i
EndIf
ElseIf $i = UBound($ARRAY)-1 Then
If $ARRAY[$i] <> $aTMP[$k][1] Then
For $x = $k To $i-1
$aTMP[$x][0] = $i-$k
Next
$k = $i
Else
For $x = $k To $i
$aTMP[$x][0] = $i-$k+1
Next
EndIf
EndIf
Next
_ArraySort_2ary($aTMP, 0, $iCol, $DESCENDING)
For $i = 0 To UBound($ARRAY)-1
$ARRAY[$i] = $aTMP[$i][1]
Next
Else
Dim $aTMP = $ARRAY
ReDim $aTMP[UBound($ARRAY)][$UBound2nd+1]
For $i = 0 To UBound($ARRAY)-1
$aTMP[$i][$UBound2nd] = 1
Next
$k = 0
For $i = 0 To UBound($ARRAY)-1
If ($i > 0) And ($i < UBound($ARRAY)-1) Then
If $ARRAY[$i][$iCol] <> $aTMP[$k][$iCol] Then
For $x = $k To $i-1
$aTMP[$x][$UBound2nd] = $i-$k
Next
$k = $i
EndIf
ElseIf $i = UBound($ARRAY)-1 Then
If $ARRAY[$i][$iCol] <> $aTMP[$k][$iCol] Then
For $x = $k To $i-1
$aTMP[$x][$UBound2nd] = $i-$k
Next
$k = $i
Else
For $x = $k To $i
$aTMP[$x][$UBound2nd] = $i-$k+1
Next
EndIf
EndIf
Next
_ArraySort_2ary($aTMP, $UBound2nd, $iCol, $DESCENDING)
For $i = 0 To UBound($ARRAY)-1
For $k = 0 To $UBound2nd-1
$ARRAY[$i][$k] = $aTMP[$i][$k]
Next
Next
EndIf
Return 0
EndFunc ;==>_Array2DSortByCountSameEntries

;===============================================================================
;
; Function Name: _Array2DPop($ARRAY)
; Description: Gibt das letzte Element eines 1D/2D-Arrays zurück und löscht dieses
; gleichzeitig vom Array
; Return: Erfolg: 1D = 1D-Array mit dem letzten Element
; 2D = 1D-Array mit jeweils einem Eintrag pro Spalte des letzten Elements
; Array[0] enthält die Anzahl der Elemente
; Fehler: Leerstring und @error = 1 ; Variable ist kein Array
; Author(s): Cephas <cephas at clergy dot net>
; Modified: BugFix ([email='bugfix@autoit.de'][/email]) ==> 2D-Anpassung
;
;===============================================================================
Func _Array2DPop(ByRef $ARRAY)
Local $LastValue = ''
Local $aOut[1], $UBound2nd = UBound($ARRAY,2)
If @error = 1 Then
Return SetError(1,0,'')
ElseIf @error = 2 Then
$UBound2nd = 1
$aOut[0] = $ARRAY[UBound($ARRAY) -1]
$LastValue = $aOut
Else
ReDim $aOut[$Ubound2nd+1]
$aOut[0] = 0
For $i = 0 To $Ubound2nd -1
$aOut[$i+1] = $ARRAY[UBound($ARRAY)-1][$i]
$aOut[0] += 1
Next
$LastValue = $aOut
EndIf
If UBound($ARRAY) = 1 Then
$ARRAY = ''
Else
If $UBound2nd = 1 Then
ReDim $ARRAY[UBound($ARRAY) -1]
Else
ReDim $ARRAY[UBound($ARRAY) -1][$UBound2nd]
EndIf
EndIf
Return $LastValue
EndFunc ;==>_Array2DPop

;=====================================================================================
;
; Function Name: _Array2DPush($ARRAY, $Value [, $Direction=0])
; Description: Fügt einem Array Werte hinzu ohne die Arraygröße zu verändern.
; Werte können vom Ende (Standard) oder vom Anfang des Arrays zugefügt werden.
; Entsprechend der Anzahl der einzufügenden Werte wird eine gleiche Anzahl Elemente
; aus dem Array 'herausgeschoben' (ge-pusht)
; Parameter(s): $ARRAY - Array
; $Value - Der einzufügende Wert, oder mehrere Werte als Array
; $Direction - 0 = Linksseitiges Schieben (Einfügen vom Ende) (Standard)
; 1 = Rechtsseitiges Schieben (Einfügen vom Anfang)
; Requirement(s): None
; Return Value(s): On Success - Returns 0
; On Failure - 1 und SetError
; @error = 1 kein Array
; @error = 2 Einfügearray größer als Originalarray
; @error = 3 Einfügearray und Originalarray haben unterschiedliche Dimensionen @error = 4 $Value ist Einzelwert, 2D-Array erwartet
; @error = 5 $Value ist 1D-Array, 2D-Array erwartet
; Author(s): Helias Gerassimou(hgeras)
; Modified: BugFix ([email='bugfix@autoit.de'][/email]) ==> 2D-Anpassung
;
;======================================================================================
Func _Array2DPush(ByRef $ARRAY, $Value, $Direction=0)
Local $i, $j, $k
Local $arStatVal = IsArray($Value)
Local $UBound1st = UBound($ARRAY)
If @error = 1 Then Return SetError(1,0,1)
Local $UBound2nd = UBound($ARRAY,2)
If @error = 2 Then
If $arStatVal Then
Local $UbValue = UBound($Value)
If $UbValue > $UBound1st Then Return SetError(2,0,1)
If UBound($Value, 2) > 0 Then Return SetError(3,0,1)
For $k = 0 To $UbValue -1
If $Direction = 0 Then
For $i = 0 To ($UBound1st -2)
$ARRAY[$i] = $ARRAY[$i+1]
Next
$i = ($UBound1st -1)
$ARRAY[$i] = $Value[$k]
Else
For $i = ($UBound1st -1) To 1 Step -1
$ARRAY[$i] = $ARRAY[$i-1]
Next
$ARRAY[$i] = $Value[$UbValue -1 -$k]
EndIf
Next
Else
If $Direction = 0 Then
For $i = 1 To $UBound1st -1
$ARRAY[$i-1] = $ARRAY[$i]
Next
$ARRAY[$UBound1st-1] = $Value
Else
For $i = $UBound1st-1 To 1 Step -1
$ARRAY[$i] = $ARRAY[$i-1]
Next
$ARRAY[0] = $Value
EndIf
EndIf
Else
Local $UbValue2nd = UBound($Value, 2)
If @error = 1 Then
Return SetError(4,0,1)
ElseIf @error = 2 Then
Return SetError(5,0,1)
ElseIf UBound($Value) > $UBound1st Then
Return SetError(2,0,1)
ElseIf $Ubound2nd <> $UbValue2nd Then
Return SetError(3,0,1)
EndIf
Local $UbValue = UBound($Value)
For $k = 0 To $UbValue -1
If $Direction = 0 Then
For $i = 0 To ($UBound1st -2)
For $j = 0 To $UBound2nd -1
$ARRAY[$i][$j] = $ARRAY[$i+1][$j]
Next
Next
$i = ($UBound1st -1)
For $j = 0 To $UBound2nd -1
$ARRAY[$i][$j] = $Value[$k][$j]
Next
Else
For $i = ($UBound1st -1) To 1 Step -1
For $j = 0 To $UBound2nd -1
$ARRAY[$i][$j] = $ARRAY[$i-1][$j]
Next
Next
For $j = 0 To $UBound2nd -1
$ARRAY[$i][$j] = $Value[$UbValue -1 -$k][$j]
Next
EndIf
Next
EndIf
Return 0
EndFunc ;==>_Array2DPush

;==================================================================================================
; Function Name: _Array2DMinMax(ByRef $ARRAY [, $MAX=0 [, $iCol=0 [, $sDelim=';']]])
; Description:: gibt den minimalen od. maximalen Wert eines 1D/2D-Array zurück
; Überprüfung einer oder aller Spalten
; Parameter(s): $ARRAY das zu prüfende Array
; $MAX 0 = Minwert (Standard); 1 = Maxwert
; $iCol SpaltenIndex 0 = Standard
; -1 = alle Spalten werden geprüft
; $sDelim Trennzeichen f. Indexwerte, Standard ';'
; mit 'Default' Zeichen von Opt('GUIDataSeparatorChar')
; Return Value(s): Erfolg Array[0] = Max/Min-Wert; Array[1] = Index(Zeile [, Spalte])
; Fehler -1 @error = 1 kein Array übergeben
; @error = 2 $iCol überschreitet UBound,2
; Author(s): BugFix ([email='bugfix@autoit.de'][/email])
;==================================================================================================
Func _Array2DMinMax(ByRef $ARRAY, $MAX=0, $iCol=0, $sDelim=';')
If Not IsArray($ARRAY) Then Return SetError(1,0,-1)
Local $Ub2nd = UBound($ARRAY, 2)-1, $arOut[2] = [0]
If $MAX <> 0 Then $MAX = 1
If $sDelim = Default Then $sDelim = Opt('GUIDataSeparatorChar')
If @error Then
For $i = 0 To UBound($ARRAY) -1
If $MAX = 1 Then
If Number($ARRAY[$i]) > $arOut[0] Then
$arOut[0] = Number($ARRAY[$i])
$arOut[1] = $i
EndIf
Else
If $i = 0 Then
$arOut[0] = Number($ARRAY[$i])
$arOut[1] = $i
EndIf
If Number($ARRAY[$i]) < $arOut[0] Then
$arOut[0] = Number($ARRAY[$i])
$arOut[1] = $i
EndIf
EndIf
Next
Else
If $iCol > $Ub2nd Then Return SetError(2,0,-1)
If $iCol < -1 Then $iCol = -1
If $iCol = -1 Then
For $i = 0 To UBound($ARRAY) -1
For $k = 0 To $Ub2nd
If $MAX = 1 Then
If Number($ARRAY[$i][$k]) > $arOut[0] Then
$arOut[0] = Number($ARRAY[$i][$k])
$arOut[1] = $i & $sDelim & $k
EndIf
Else
If $i = 0 Then
$arOut[0] = Number($ARRAY[$i][$k])
$arOut[1] = $i & $sDelim & $k
EndIf
If Number($ARRAY[$i][$k]) < $arOut[0] Then
$arOut[0] = Number($ARRAY[$i][$k])
$arOut[1] = $i & $sDelim & $k
EndIf
EndIf
Next
Next
Else
For $i = 0 To UBound($ARRAY) -1
If $MAX = 1 Then
If Number($ARRAY[$i][$iCol]) > $arOut[0] Then
$arOut[0] = Number($ARRAY[$i][$iCol])
$arOut[1] = $i & $sDelim & $iCol
EndIf
Else
If $i = 0 Then
$arOut[0] = Number($ARRAY[$i][$iCol])
$arOut[1] = $i & $sDelim & $iCol
EndIf
If Number($ARRAY[$i][$iCol]) < $arOut[0] Then
$arOut[0] = Number($ARRAY[$i][$iCol])
$arOut[1] = $i & $sDelim & $iCol
EndIf
EndIf
Next
EndIf
EndIf
Return $arOut
EndFunc ;==>_Array2DMinMax