Beiträge von eukalyptus

[autoit]

;===werden benötigt=============================================================
#include<String.au3>
#include<WindowsConstants.au3>
#include<Misc.au3>
;===============================================================================

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

;===Beispiel 1 (komplettes Verzeichnis kopieren)================================
; Alle Dateien und Unterverzeichnisse (rekursiv) werden kopiert
; Verzeichnisstruktur der Quelle wird übernommen
Global $sSourcePath = 'C:\Programme\AutoIt3\AutoitX'
Global $sDestinationPath = @ScriptDir & '\Tmp1'; Zielpfad (wird ggf. erstellt)

[/autoit] [autoit][/autoit] [autoit]

$Ret=_MultiFileCopy($sSourcePath, $sDestinationPath)
For $i= 1 to $Ret[0]
MsgBox(0, "Dateien überschreiben", $i & " / " & $Ret[0] & @CRLF & $Ret[$i])
Next
;===============================================================================

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

;===Beispiel 2 (mehrere Dateien kopieren)=======================================
; Alle Dateien aus dem Array werden ins Zielverzeichnis kopiert
; Array[0] muss die Anzahl der zu kopierenden Dateien enthalten
Global $aSource[4] = [3, @SystemDir & '\shell32.dll', @SystemDir & '\mspaint.exe', @SystemDir & '\eula.txt']
Global $sDestinationPath = @ScriptDir & '\Tmp2'; Zielpfad (wird ggf. erstellt)

[/autoit] [autoit][/autoit] [autoit]

$Ret=_MultiFileCopy($aSource, $sDestinationPath, False)
For $i= 1 to $Ret[0]
MsgBox(0,"Vorhandene Dateien umbenennen", $i & " / " & $Ret[0] & @CRLF & $Ret[$i])
Next
;===============================================================================

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

;===============================================================================
;
; Function Name: _MultiFileCopy
; Description:: Kopiert mehrere Dateien mit Progressbar
; Parameter(s): Array mit Dateien zum kopieren, Zielpfad
; Requirement(s):
; #include<String.au3>
; #include<WindowsConstants.au3>
; #include<Misc.au3>
; Author(s): Tom99, progandy and Oscar (http://www.autoit.de)
;
;===============================================================================
;
Func _MultiFileCopy($aSource, $sDestPath, $bOverWrite = True, $sPreFix = "Copy")
Local $opt = Opt('GUICloseOnESC', 0), $ret, $sShowSource, $sShowDest, $sSourcePath = '', $sNewFolder = '', $i, $j, $k
Local $aMFC[12] = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, False, DllOpen('user32.dll')]
If Not IsArray($aSource) Then
$sSourcePath = $aSource
If StringRight($sSourcePath, 1) <> '\' Then $sSourcePath &= '\'
ToolTip('Bitte warten! Verzeichnis wird eingelesen!')
$aSource = _GetFilesFolder_Rekursiv($aSource, '*', 0)
ToolTip('')
Else
If Not IsNumber($aSource[0]) Then Return SetError(1, 0, 0)
EndIf
Local $aReturn = $aSource
If StringRight($sDestPath, 1) <> '\' Then $sDestPath &= '\'
If Not FileExists($sDestPath) Then
If Not DirCreate($sDestPath) Then Return SetError(2, 0, 0)
EndIf
$sShowDest = StringRegExpReplace($sDestPath, '(.{15})(.*)(.{35})', '$1' & '[...]' & '$3')
Local $aFileSize[UBound($aSource)]
For $i = 1 To $aSource[0]
$aFileSize[$i] = FileGetSize($aSource[$i])
$aMFC[7] += $aFileSize[$i]
Next
Local $callback = DllCallbackRegister('__Progress', 'int', 'uint64;uint64;uint64;uint64;dword;dword;ptr;ptr;str')
Local $ptr = DllCallbackGetPtr($callback)
__ProgressCreate($aMFC)
$aMFC[9] = TimerInit()
For $i = 1 To $aSource[0]
$sArray = ''
For $j = 0 To 11
$sArray &= $aMFC[$j] & ';'
Next
If $sSourcePath <> '' Then
$sNewFolder = StringTrimLeft(StringLeft($aSource[$i],StringInStr($aSource[$i],"\",0,-1)),StringLen($sSourcePath))
If Not FileExists($sDestPath & $sNewFolder) Then
If Not DirCreate($sDestPath & $sNewFolder) Then Return SetError(3, 0, 0)
EndIf
EndIf
$sFile = StringMid($aSource[$i], StringInStr($aSource[$i], '\', 0, -1) + 1)
$k = 0
While $bOverWrite=False And FileExists($sDestPath & $sNewFolder & $sFile)
$k+=1
$sFile=$sPreFix & $k & "_" & StringMid($aSource[$i], StringInStr($aSource[$i], '\', 0, -1) + 1)
WEnd
$sShowSource = StringRegExpReplace($aSource[$i], '(.{15})(.*)(.{35})', '$1' & '[...]' & '$3')
GUICtrlSetData($aMFC[1], 'Kopiere Datei ' & @CRLF & '"' & $sShowSource & '"' & @CRLF & 'nach: "' & $sShowDest & '"')
$ret = DllCall('kernel32.dll', 'int', 'CopyFileExA', 'str', $aSource[$i], 'str', $sDestPath & $sNewFolder & $sFile, 'ptr', $ptr, 'str', $sArray, 'int', 0, 'int', 0)
$aReturn[$i] = $sDestPath & $sNewFolder & $sFile
;~ ConsoleWrite('Return: ' & $ret[0] & @LF)
If $ret[0] = 0 Then $aMFC[10] = True
$aMFC[8] += $aFileSize[$i]
Next
GUIDelete($aMFC[0])
DllClose($aMFC[11])
Opt('GUICloseOnESC', $opt)
Return $aReturn
EndFunc ;==>_MultiFileCopy

[/autoit] [autoit][/autoit] [autoit]

Func __ProgressCreate(ByRef $aMFC)
$aMFC[0] = GUICreate('FileCopy', 480, 220, -1, -1, $WS_POPUPWINDOW)
$aMFC[1] = GUICtrlCreateLabel('', 10, 10, 460, 65)
GUICtrlSetFont(-1, 10, 400, 0, 'Courier New')
GUICtrlCreateLabel('Datei:', 10, 83, 60, 16)
GUICtrlSetFont(-1, 11, 600, 0, 'Courier New')
$aMFC[2] = GUICtrlCreateLabel('0 %', 80, 83, 390, 16)
GUICtrlSetFont(-1, 11, 600, 0, 'Courier New')
$aMFC[4] = GUICtrlCreateProgress(10, 100, 460, 20)
GUICtrlCreateLabel('Gesamt:', 10, 133, 60, 16)
GUICtrlSetFont(-1, 11, 600, 0, 'Courier New')
$aMFC[3] = GUICtrlCreateLabel('0 %', 80, 133, 390, 16)
GUICtrlSetFont(-1, 11, 600, 0, 'Courier New')
$aMFC[5] = GUICtrlCreateProgress(10, 150, 460, 20)
$aMFC[6] = GUICtrlCreateButton('Abbrechen', 200, 185, 75, 25)
GUICtrlSetFont(-1, 9, 400, 0, 'Arial')
GUISetState()
Sleep(200)
EndFunc ;==>__ProgressCreate

[/autoit] [autoit][/autoit] [autoit]

Func __Progress($FileSize, $BytesTransferred, $StreamSize, $StreamBytesTransferred, $dwStreamNumber, $dwCallbackReason, $hSourceFile, $hDestinationFile, $lpData)
Local $aSplit = StringSplit(StringTrimRight($lpData, 1), ";")
If $aSplit[11] = 'True' Then Return 1
Local $pos = GUIGetCursorInfo($aSplit[1])
If _IsPressed('1B', Int($aSplit[12])) Then Return 1
If _IsPressed('01', Int($aSplit[12])) And ($pos[4] = Int($aSplit[7])) Then Return 1
Local $sPercent = Round($BytesTransferred / $FileSize * 100, 0), $iTime, $iTotalTime, $iTransferRate
Local $sPercentAll = Round(($aSplit[9] + $BytesTransferred) / $aSplit[8] * 100, 0)
If GUICtrlRead($aSplit[5]) <> $sPercent Then
$iTime = TimerDiff($aSplit[10])
$iTotalTime = Ceiling($iTime / 1000 / ($sPercentAll + 0.1) * 100)
$iTransferRate = _StringAddThousandsSep(Int($aSplit[8] / $iTotalTime / 1000), '.', ',')
GUICtrlSetData($aSplit[3], $sPercent & ' %')
GUICtrlSetData($aSplit[5], $sPercent)
If GUICtrlRead($aSplit[6]) <> $sPercentAll Then
GUICtrlSetData($aSplit[4], $sPercentAll & ' % Zeit: ' & Int($iTime / 1000) & '/' & $iTotalTime & ' s (' & $iTransferRate & ' KB/s)')
GUICtrlSetData($aSplit[6], $sPercentAll)
EndIf
EndIf
EndFunc ;==>__Progress

[/autoit] [autoit][/autoit] [autoit]

;==================================================================================================
; Function Name: _GetFilesFolder_Rekursiv($sPath [, $sExt='*' [, $iDir=-1 [, $iRetType=0 ,[$sDelim='0']]]])
; Description: Rekursive Auflistung von Dateien und/oder Ordnern
; Parameter(s): $sPath der Basispfad für die Auflistung ('.' -aktueller Pfad, '..' -Parentpfad)
; $sExt Erweiterung für Dateiauswahl '*' oder -1 für alle (Standard)
; $iDir -1 Dateien+Ordner(Standard), 0 nur Dateien, 1 nur Ordner
; optional: $iRetType 0 gibt Array, 1 gibt String zurück
; optional: $sDelim legt Trennzeichen für Stringrückgabe fest
; 0 -@CRLF (Standard) 1 -@CR 2 -@LF 3 -';' 4 -'|'
; Return Value(s): Array (Standard) od. String mit den gefundenen Pfaden der Dateien und/oder Ordner
; Array[0] enthält die Anzahl der gefundenen Dateien/Ordner
; Author(s): BugFix ([email='bugfix@autoit.de'][/email])
;==================================================================================================
Func _GetFilesFolder_Rekursiv($sPath, $sExt='*', $iDir=-1, $iRetType=0, $sDelim='0')
Global $oFSO = ObjCreate('Scripting.FileSystemObject')
Global $strFiles = ''
Switch $sDelim
Case '1'
$sDelim = @CR
Case '2'
$sDelim = @LF
Case '3'
$sDelim = ';'
Case '4'
$sDelim = '|'
Case Else
$sDelim = @CRLF
EndSwitch
If ($iRetType < 0) Or ($iRetType > 1) Then $iRetType = 0
If $sExt = -1 Then $sExt = '*'
If ($iDir < -1) Or ($iDir > 1) Then $iDir = -1
_ShowSubFolders($oFSO.GetFolder($sPath),$sExt,$iDir,$sDelim)
If $iRetType = 0 Then
Local $aOut
$aOut = StringSplit(StringTrimRight($strFiles, StringLen($sDelim)), $sDelim, 1)
If $aOut[1] = '' Then
ReDim $aOut[1]
$aOut[0] = 0
EndIf
Return $aOut
Else
Return StringTrimRight($strFiles, StringLen($sDelim))
EndIf
EndFunc

[/autoit] [autoit][/autoit] [autoit]

Func _ShowSubFolders($Folder, $Ext='*', $Dir=-1, $Delim=@CRLF)
If Not IsDeclared("strFiles") Then Global $strFiles = ''
If ($Dir = -1) Or ($Dir = 0) Then
For $file In $Folder.Files
If $Ext <> '*' Then
If StringRight($file.Name, StringLen($Ext)) = $Ext Then _
$strFiles &= $file.Path & $Delim
Else
$strFiles &= $file.Path & $Delim
EndIf
Next
EndIf
For $Subfolder In $Folder.SubFolders
If ($Dir = -1) Or ($Dir = 1) Then $strFiles &= $Subfolder.Path & '\' & $Delim
_ShowSubFolders($Subfolder, $Ext, $Dir, $Delim)
Next
EndFunc

[/autoit]

[autoit]

#include-once

[/autoit] [autoit][/autoit] [autoit]

Global $L, $R, $E, $T, $i, $j, $C

[/autoit] [autoit][/autoit] [autoit]

Func _BigInt_Add($a, $b)
$L = StringLen($a)
$T = StringLen($b)
$R=0
$E=""
If $L < $T Then $L=$T
For $i = $L To 1 Step -14
$T = StringRight($a, 14) + StringRight($b, 14) + $R
$a = StringTrimRight($a, 14)
$b = StringTrimRight($b, 14)
$R = Floor($T / 100000000000000)
$T = Mod($T, 100000000000000)
If $i > 14 And $T <= 10000000000000 Then $T = StringRight("00000000000000" & $T, 14)
$E = $T & $E
Next
Return $E
EndFunc ;==>_BigInt_Add

[/autoit] [autoit][/autoit] [autoit]

Func _BigInt_Mul($a, $b)
$a = _Split7($a)
$b = _Split7($b)
Local $E[$a[0] + $b[0]] = [$a[0] + $b[0] - 1]
For $i = 1 To $b[0]
For $j = 1 To $a[0]
$E[$j + $i - 1] += $a[$j] * $b[$i]
Next
Next
Return _Merge7($E)
EndFunc ;==>_BigInt_Mul

[/autoit] [autoit][/autoit] [autoit]

Func _Merge7($a)
$E=""
$R=0
For $i = $a[0] To 1 Step -1
$a[$i] += $R
$R = Floor($a[$i] / 10000000)
$T = Mod($a[$i], 10000000)
If $i > 1 And $T <= 10000000 Then $T = StringRight("00000000000000" & $T, 7)
$E = $T & $E
Next
If $R > 0 Then $E = $R & $E
If $E = 0 Then $E = "0"
Return $E
EndFunc ;==>_Merge7

[/autoit] [autoit][/autoit] [autoit]

Func _Split7($a)
$L = StringLen($a)
$C = Ceiling($L / 7)
Local $E[$C + 1]
For $i = $L To 1 Step -7
$E[$C] = StringRight($a, 7)
$a = StringTrimRight($a, 7)
$C -= 1
Next
$E[0] = Ceiling($L / 7)
Return $E
EndFunc ;==>_Split7

[/autoit] [autoit][/autoit] [autoit]

Func _BigInt_Load($a)
Return $a
EndFunc ;==>_BigInt_Load

[/autoit] [autoit][/autoit] [autoit]

Func _BigInt_Print($a)
While StringLeft($a, 1) = "0" And StringLen($a) > 1
$a = StringTrimLeft($a, 1)
WEnd
Return $a
EndFunc ;==>_BigInt_Print

[/autoit]

Schulmethode:
456*123
---------
45600
.9120
..1368
-------
56088

hier werden alle einzelnen Ziffern miteinander multipliziert, der Übertrag an die nächste weitergegeben und die Teilergebnisse addiert.
Wenn man sich die Teilergebnisse nun anschaut, stellt man fest, daß die Stelle von 6*1 in einem anderen Teilergebnis 5*2 und im nächsten 4*3 ist.
So komm ich auf meine Methode. Ich spare mir den Übertrag vorerst und addiere die einzelnen Multiplikationen gleich

Meine Methode: (Bei meinem Script verwende ich 7-stellige Array´s; zum Veranschaulichen hier nur 1-stellige)
jede Ziffer kommt in ein eigenes Array: [4] [5] [6] * [1] [2] [3]
Das Ergebnis ist auch ein Array:
[1] = 4*1 = 4
[2] = 5*1 + 4*2 = 13
[3] = 6*1 + 5*2 + 4*3 = 28
[4] = 6*2 + 5*3 = 27
[5] = 6*3 = 18

nun hab ich: [4] [13] [28] [27] [18]
dieses Array füge ich nun zum Ergebnis, indem ich hier nun von rechts nach links den Übertrag weitergebe:
Einserstelle [18] des Ergebnis ist 8, Übertrag zu Zehnerstelle [27] ist 1...usw.
[4] [13] [28] [27] [18]=
56088

Die Geschwindigkeit erreiche ich dadurch, daß ich NICHT für jedes Teilergebnis den Übertrag berechne, sondern erst am Schluß und das nur 1Mal!
Außerdem sind die einzelnen Additionen so klein, daß ich die Autoit-Addition verwenden kann.

an dieser Stelle möchte ich auch gleich ein Problem darstellen:
betrachten wir eine Zeile von oben: [3] = 6*1 + 5*2 + 4*3 = 28
Je länger die zu berechnenden Zahlen sind, desto länger wird auch diese Zeile!
theoretisch wird irgendwann die berechenbare Grenze erreicht, also wenn das Ergebnis dieser Zeile für Autoit zu groß wird.
Für diesen Fall benötigt man dann eine andere Lösung (Zwischendurch Übertrag berechnen und diese Teilergebnisse mit _BigIn_Add zusammenzählen...?!)

[autoit]

#include-once
Func _BigInt_Add($a,$b)
If $a[0]<$b[0]Then
$S=$a
$a=$b
$b=$S
EndIf
For $i=1 To $a[0]
If $i>$a[0]-$b[0]Then $a[$i]+=$b[$i-($a[0]-$b[0])]
Next
Return $a
EndFunc
Func _BigInt_Mul($a,$b)
Local $E[$a[0]+$b[0]]=[$a[0]+$b[0]-1]
For $i=1 To $b[0]
For $j=1 To $a[0]
$E[$j+$i-1]+=$a[$j]*$b[$i]
Next
Next
Return $E
EndFunc
Func _BigInt_Load($a)
Return StringSplit($a,"")
EndFunc
Func _BigInt_Print($a,$E="",$R=0)
For $i=$a[0]To 1 Step -1
$a[$i]+=$R
$R=Floor($a[$i]/10)
$E=Mod($a[$i],10)&$E
Next
If $R>0 Then $E=$R&$E
If $E=0 Then $E="0"
Return $E
EndFunc

[/autoit]

[autoit]

#include-once

[/autoit] [autoit][/autoit] [autoit]

Global $L, $R, $E, $T, $i, $j, $C ;Ich verwende 1-stellige Variablen, da ich behaupte, daß das performanceverbesserungen bringt
;UND ich deklariere alle als Global, damit die Functions nicht erst deklarieren müssen...

[/autoit] [autoit][/autoit] [autoit]

Func _BigInt_Add($a, $b)
$L = StringLen($b)
$T = StringLen($a)
$R=0
$E=""
If $L > $T Then $L=$T ;für die Schleife wird die kürzere Zahl genommen; Ich behaupte jetzt, daß die anderen Teilnehmer die längere Zahl verwendet haben...*g* - siehe "Return"
For $i = $L To 0 Step -15 ;Warum gerade 15? - wenn man Stringzahlen mit Auoit addiert, gehen max 14-stellige Zahlen (beim Benchmark 15 *g*); komischerweise funktionieren bei Integer 18-stellige Zahlen...
$T = StringRight($a, 15) + StringRight($b, 15) + $R ; Wird addiert lt. Schulmethode incl. Rest, welcher sich erst in der Schleife ergibt
$a = StringTrimRight($a, 15) ;verarbeitete Stellen steichen
$b = StringTrimRight($b, 15)
$R = Floor($T / 1000000000000000) ;Rest wird ermittelt
$T = Mod($T, 1000000000000000) ;Tatsächlicher Wert, der zu Ergebnis kommt
If $T <= 100000000000000 Then $T = StringRight("000" & $T, 15) ; Bei Rechenoperationen werden die führenden Nullen gestrichen, wir benötigen aber immer 15-stellige Strings (normallerweise sollten da 15 Nullen sein, bei Pee´s Benchmark reichen aber 3 :))
$E = $T & $E
Next
Return $a&$b&$E ;da ich die kürzere Zahl in der Schleife hab, muß ich den Rest der längeren Zahl vorne dran heften (ka, ob das immer funktioniert, beim Benchmark funzt´s - evtl fehlt bei anderen Zahlen mal ein Rest ?!)
EndFunc ;==>_BigInt_Add

[/autoit] [autoit][/autoit] [autoit]

Func _BigInt_Mul($a, $b) ;die Zahlen werden in ein Array gesplittet und dann lt Schulmethode berechnet; Siehe unten...
$a = _Split7($a)
$b = _Split7($b)
Local $E[$a[0] + $b[0]] = [$a[0] + $b[0] - 1] ;Die Stellenlänge bei MUL ist immer max. Länge_a + Länge_b
For $i = 1 To $b[0]
For $j = 1 To $a[0]
$E[$j + $i - 1] += $a[$j] * $b[$i] ;ich addiere die Multiplikationswerte im Array und lasse sie erst später mit _Merge7() zusammenfügen (Siehe ganz unten; geht das immer, oder kann der Wert die 14 Stellige Autoit-Grenze überscheiten??!)
Next
Next
Return _Merge7($E)
EndFunc ;==>_BigInt_Mul

[/autoit] [autoit][/autoit] [autoit]

Func _Merge7($a) ; Addiert die einzelnen Array-Werte lt. Schulmethode, übergibt den Rest an die nächste usw...(im Prinzip wie bei _BigInt_add)
$E=""
$R=0
For $i = $a[0] To 1 Step -1
$a[$i] += $R
$R = Floor($a[$i] / 10000000)
$T = Mod($a[$i], 10000000)
If $i > 1 And $T <= 10000000 Then $T = StringRight("00" & $T, 7) ;wieder wie oben, nur halt 7-stellig...
$E = $T & $E
Next
If $R > 0 Then $E = $R & $E
If $E = 0 Then $E = "0"
Return $E
EndFunc ;==>_Merge7

[/autoit] [autoit][/autoit] [autoit]

Func _Split7($a) ;Splittet die Zahl in ein Array mit jeweils 7-stelligen Zahlen; Warum 7 ?: weil 7+7=14 und 14-stellige Strings sind das Maximum, was Autoit addieren kann
$L = StringLen($a)
$C = Ceiling($L / 7)
Local $E[$C + 1]
For $i = $L To 1 Step -7
$E[$C] = StringRight($a, 7)
$a = StringTrimRight($a, 7)
$C -= 1
Next
$E[0] = Ceiling($L / 7)
Return $E
EndFunc ;==>_Split7

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

Func _BigInt_Load($a)
Return $a
EndFunc ;==>_BigInt_Load

[/autoit] [autoit][/autoit] [autoit]

Func _BigInt_Print($a)
While StringLeft($a, 1) = "0" And StringLen($a) > 1 ;Führende Nullen werden gestrichen (ist schneller als StringRegExpReplace($X,"^[0-]*",""))
$a = StringTrimLeft($a, 1)
WEnd
Return $a
EndFunc ;==>_BigInt_Print

[/autoit] [autoit][/autoit] [autoit]

;Zu Mul:
;Bei der Schulmethode werden die einzelnen Zahlen multipliziert, der Rest weitergegeben und am Schluß die Teilergebnisse addiert... (das geht auch 7-stellig, hab ich in irgendeiner Version auch gemacht...)
;ich addiere die einzelnen Multiplikationen im Array und mach das mit dem Restübergeben erst bei _Merge7!
;wenn theoretisch ein Array den Wert von 14 Stellen überschreitet, dann gibts evtl. ein Problem! Beim Benchmark geht´s, aber geht das auch mit beliebig langen Zahlen?!?

[/autoit]

[autoit]

Func _Useless()
EndFunc

[/autoit]