Beiträge von UEZ

// Leibniz-PI.cpp : Defines the entry point for the console application.
//


#include "stdafx.h"
#include <iostream>
#include <limits>
#include <chrono>


using namespace std;
typedef std::numeric_limits< double > dbl;


void main()
{


	auto start = std::chrono::high_resolution_clock::now();




	unsigned int k, n = 10000000;
	double fPI = 0.0, fSign = 1.0;
	for (k = 0; k < n; k++) {
		fPI += fSign / ((k << 1) + 1);
		fSign = -fSign;
	}
	fPI *= 4.0;




	auto end = std::chrono::high_resolution_clock::now();


	std::chrono::duration<double> elapsed = end - start;


	cout.precision(dbl::max_digits10);
	cout << "Pi: " << fPI << '\t' << elapsed.count() * 1000 << " ms for " << n << " iterations." << endl;


	cin.get();
}

// Leibniz-PI.cpp : Defines the entry point for the console application.
//


#include "stdafx.h"
#include <iostream>
#include <limits>
#include <ctime>


using namespace std;
typedef std::numeric_limits< double > dbl;


double Leibniz_PI(int n)
{
	double fPI;
	int k;
	fPI = 0.0;
	for (k = 0; k < n; k++) {
		fPI += (pow(-1, k)) / (2 * k + 1);
	}
    return 4 * fPI;
}


void main()
{
	clock_t begin = clock();
	double fResult = Leibniz_PI(10000000);
	clock_t end = clock();
	double elapsed_msecs = double(end - begin) / CLOCKS_PER_SEC * 1000.0;


	cout.precision(dbl::max_digits10);
	cout << "Pi: " << fResult << '\t' << elapsed_msecs << " ms" << endl;


	cin.get();
}

.globl _LEIBNIZ_PI@4
_LEIBNIZ_PI@4:
push ebp
mov ebp, esp
sub esp, 24
mov dword ptr [ebp-8], 0
mov dword ptr [ebp-4], 0
.Lt_0004:
mov dword ptr [ebp-12], 0
movlpd xmm7, [_Lt_000B]
movlpd [ebp-20], xmm7
mov dword ptr [ebp-12], 0
mov eax, dword ptr [ebp+8]
add eax, 4294967295
mov dword ptr [ebp-24], eax
jmp .Lt_0007
.Lt_000A:
mov eax, dword ptr [ebp-12]
and eax, 0xFFFF
cvtsi2sd xmm6, eax
mov eax, dword ptr [ebp-12]
shr eax, 16
cvtsi2sd xmm7, eax
mulsd xmm7, qword ptr [_Lt_000E]
addsd xmm6, xmm7
sub esp, 8
movlpd [esp], xmm6
push dword ptr [_Lt_000C+4]
push dword ptr [_Lt_000C]
call _pow
add esp, 16
mov eax, dword ptr [ebp-12]
shl eax, 1
inc eax
mov ecx, eax
and ecx, 0xFFFF
cvtsi2sd xmm6, ecx
mov ecx, eax
shr ecx, 16
cvtsi2sd xmm7, ecx
mulsd xmm7, qword ptr [_Lt_000E]
addsd xmm6, xmm7
sub esp, 8
fstp qword ptr [esp]
movlpd xmm0, qword ptr [esp]
add esp, 8
divsd xmm0, xmm6
addsd xmm0, qword ptr [ebp-20]
movlpd [ebp-20], xmm0
.Lt_0008:
inc dword ptr [ebp-12]
.Lt_0007:
mov eax, dword ptr [ebp-24]
cmp dword ptr [ebp-12], eax
jbe .Lt_000A
.Lt_0009:
movlpd xmm0, [_Lt_000D]
mulsd xmm0, qword ptr [ebp-20]
movlpd [ebp-8], xmm0
.Lt_0005:
fld qword ptr [ebp-8]
mov esp, ebp
pop ebp
ret 4
.balign 16

Function Leibniz_PI(n As UInteger) As Double
	Dim As Double fPI = 0.0
	For k As UInteger = 0 To n - 1
		fPI += (-1)^k / (2 * k + 1)
	Next
	Return 4 * fPI
End Function


Dim As UInteger iterations = 10000000
Dim As Double fTimer = Timer
Print Leibniz_PI(iterations), 1000 * (Timer - fTimer) & " ms for " & iterations & " iterations."


Sleep

#include <Array.au3>


$numbers = "40,3,-2.5,-10,1000,-20202.188, +50,-1.937462,3.14"
ConsoleWrite("Fünftkleinste Zahl: " & nNumber($numbers, 5, 0) & @CRLF) ; fünftkleinste Zahl
ConsoleWrite("Drittgrößte Zahl: " & nNumber($numbers, 3, 1) & @CRLF) ; drittgrößte Zahl


; #FUNCTION# =====================================================================================================================
; Name...........: 		nthNumber
; Description ...:	 	Returns the nth biggest or smallest number
; Syntax.........: 		nNumber($numbers, $n, $dir = 0)
; Parameters ....: 		$numbers - the numbers either from a string or from an array
;                  				$n - search for n biggest or smallest number where n is an integer
;                 				$dir - 0 search for smallest number, 1 for biggest number
; Return values .: 	Success - Returns the appropriate number and set @error to 0
;                  				Failure - Returns error code:
;                  				1 - Wrong delimiter in string! Valid is comma (,) only!
;                  				2 - No numbers found!
;                 				3 - n is not an integer
;                  				4 - n is not in boundary of amount of numbers
; Remarks .......: 		Needs the function CompSort() for sorting the internal array
; Author ........: 		UEZ
; Version .......: 		0.90 Build 2010-11-11 Beta
; ================================================================================================================================
Func nNumber($numbers, $n, $dir = 0)
	If IsArray($numbers) Then
		$num = _ArrayToString($numbers, ",")
		If @error Then Return SetError(1, 0, "Error! Wrong delimiter in string! Valide is comma (,) only!")
		$numbers = $num
	EndIf
	Local $aNum = StringRegExp($numbers, "(-\d+\.\d+|\d+\.\d+|\d+)", 3)
	If Not IsArray($aNum) Then Return SetError(2, 0, "Error! No numbers found!")
	If Not IsInt($n) Then Return SetError(3, 0, "Error! n is not an integer")
	If $n < 1 Or $n > UBound($aNum) - 1 Then Return SetError(4, 0, "Error! n is not in boundary of amount of numbers")
	CompSort($aNum)
	If Not $dir Then Return $aNum[$n - 1] ;n smallest number
	Return $aNum[UBound($aNum) - $n] ;n biggest number
EndFunc


;Die Komplexität liegt je nach Ausgangssituation zwischen O(n^2) (Worst-Case) und O(n*log(n)) (Best-Case).
;Im Best-Case ist die Liste der zu sortierenden Elemente geordnet, sobald die Schrittlänge 1 beträgt.
;Im Worst-Case müssen alle benachbarten Elemente nochmals getauscht werden (mehrere Durchgänge mit Schrittlänge 1).
;In diesem Fall ist Combsort nicht schneller als Bubblesort.
;Speicherverbrauch: O(c)
;Shrink-Faktor: 1/(1-1/e^phi) = 1.247330950103979, phi = 1.61803398874994
Func CompSort(ByRef $aArray)
	Local $gap = UBound($aArray)
	Local $swaps, $i, $tmp
	Do
		$gap = Int($gap / 1.247330950103979)
		If $gap < 1 Then $gap = 1
		$i = 0
		$swaps = 0
		Do
			If Number($aArray[$i]) > Number($aArray[$i + $gap]) Then
				$tmp= Number($aArray[$i])
				$aArray[$i] = Number($aArray[$i + $gap])
				$aArray[$i + $gap] = $tmp
				$swaps = 1
			EndIf
			$i += 1
		Until $i + $gap > UBound($aArray) - 1
	Until $gap = 1 And $swaps = 0
EndFunc