#ifndef RND2_H_
#define RND2_H_

void srnd2(unsigned long int seed);
unsigned long int rnd2();

#endif

unsigned long int __seed0, __seed1, __seed2, __seed3;

unsigned long int __rol(unsigned long int value, unsigned char offset)
{
	offset = offset & 0x1f;
	return (value << offset) | (value >> (0x20 - offset));
}

unsigned long int __ror(unsigned long int value, unsigned char offset)
{
	offset = offset & 0x1f;
	return (value >> offset) | (value << (0x20 - offset));
}

void srnd2(unsigned long int seed)
{
	__seed0 = seed;
	__seed1 = __seed0 ^ 0xaaaaaaaa;
	__seed1 = __rol(__seed1 >> 11, __seed1);
	__seed1 = __seed1 ^ (__seed1 >> 21);
	__seed2 = __seed0 ^ 0x55555555;
	__seed2 = __ror(__seed2 << 6, __seed2);
	__seed2 = __seed2 ^ (__seed2 >> 22);
	__seed3 = (__seed2 << 16) | (__seed1 >> 16);
}

unsigned long int rnd2()
{
	__seed1 = __rol(__seed1, 5);
	__seed2 = __ror(__seed2, 9);
	__seed0 = __rol(__seed0, 11);
	__seed0 ^= __seed1;
	__seed0 ^=  __rol(__seed1, 8) << 11;
	__seed0 ^= __ror(__seed2, 8) & 63;
	__seed0 ^= __rol(__seed3, 8) >> 5;
	__seed0 = __ror(__seed0, 14);
	__seed0 ^= __seed3;
	__seed1 ^= __seed3;
	__seed2 ^= __seed3;
	__seed3 = __ror(__seed3, __seed0);
	return __seed0;
}

#include <cstdlib>
#include <ctime>
#include "rnd2.h"

int main() {
    srnd2(time(NULL));
    int table[256];
    int i, j, k, r, temp;
    for (i = 0; i < 1000; i++) {
	for (j = 0; j < 1000; j++) {
	    for (k = 0; k < 256; k++) table[k] = k;
	    for (k = 0; k < 256; k++) {
		r = rnd2() & 255;
		temp = table[r];
		table[k] = temp;
	    }
	}
    }
    return 0;
}

#ifndef CRND2_H_
#define CRND2_H_

class CRnd2 {
public:
    void srnd2(unsigned long int seed);
    unsigned long int rnd2();
private:
    unsigned long int __seed0;
    unsigned long int __seed1;
    unsigned long int __seed2;
    unsigned long int __seed3;

    unsigned long int __rol(unsigned long int value, unsigned char offset);
    unsigned long int __ror(unsigned long int value, unsigned char offset);

};

#endif

#include "CRnd2.h"

unsigned long int CRnd2::__rol(unsigned long int value, unsigned char offset)
{
	offset = offset & 0x1f;
	return (value << offset) | (value >> (0x20 - offset));
}

unsigned long int CRnd2::__ror(unsigned long int value, unsigned char offset)
{
	offset = offset & 0x1f;
	return (value >> offset) | (value << (0x20 - offset));
}

void CRnd2::srnd2(unsigned long int seed)
{
	__seed0 = seed;
	__seed1 = __seed0 ^ 0xaaaaaaaa;
	__seed1 = __rol(__seed1 >> 11, __seed1);
	__seed1 = __seed1 ^ (__seed1 >> 21);
	__seed2 = __seed0 ^ 0x55555555;
	__seed2 = __ror(__seed2 << 6, __seed2);
	__seed2 = __seed2 ^ (__seed2 >> 22);
	__seed3 = (__seed2 << 16) | (__seed1 >> 16);
}

unsigned long int CRnd2::rnd2()
{
	__seed1 = __rol(__seed1, 5);
	__seed2 = __ror(__seed2, 9);
	__seed0 = __rol(__seed0, 11);
	__seed0 ^= __seed1;
	__seed0 ^=  __rol(__seed1, 8) << 11;
	__seed0 ^= __ror(__seed2, 8) & 63;
	__seed0 ^= __rol(__seed3, 8) >> 5;
	__seed0 = __ror(__seed0, 14);
	__seed0 ^= __seed3;
	__seed1 ^= __seed3;
	__seed2 ^= __seed3;
	__seed3 = __ror(__seed3, __seed0);
	return __seed0;
}

#include <cstdlib>
#include <ctime>
#include "CRnd2.h"

int main() {
    CRnd2 rnd = CRnd2();
    rnd.srnd2(time(NULL));
    int table[256];
    int i, j, k, r, temp;
    for (i = 0; i < 1000; i++) {
	for (j = 0; j < 1000; j++) {
	    for (k = 0; k < 256; k++) table[k] = k;
	    for (k = 0; k < 256; k++) {
		r = rnd.rnd2() & 255;
		temp = table[r];
		table[k] = temp;
	    }
	}
    }
    
    return 0;
}

kemi242@linuxmint ~/a $ time ./imp

real	0m21.088s
user	0m21.077s
sys	0m0.004s
kemi242@linuxmint ~/a $ time ./imp_O3

real	0m2.430s
user	0m2.424s
sys	0m0.000s
kemi242@linuxmint ~/a $ time ./oop

real	0m29.269s
user	0m29.266s
sys	0m0.000s
kemi242@linuxmint ~/a $ time ./oop_O3

real	0m2.454s
user	0m2.444s
sys	0m0.004s
kemi242@linuxmint ~/a $ 

@kemi:
Úgy látszik, az O3 kapcsoló nagyrészt kioptimalizálja az OOP hátrányait, ahol tudja.

@kemi:
Az OOP megoldásnak megvan az az előnye, hogy tudsz egyszerre több egymástól független randomgenerátort használni.

@kemi:
És elég jól kioptimalizálódott, hiszen csak néhány századmásodperccel lassabb.

@TCH:
Imperatív megoldásnál talán nem?

@TCH:
És ugye nem csak simán ojjektum, mert az még hagyján, de amikor az ojjektumból is ojjektum nyílik és a kiterjesztés kiterjesztésének a kiterjesztését is kiterjesztjük, akkor egy idő után utólérjük a dzsuva ciszta duót, hiszen azok műküdnek így.

@kemi:
Mondjuk hogy oldod meg, hogy lehessen egy eljárásban random számokat előállítani két különböző seeddel?

@kemi:
Az Object-től minden osztály örökli a default konstruktort, destruktort, meg a default operátorokat.

@kemi:
De azért ne felejtsd el, hogy ez gépi kódra fordul, és nem valami virtuális gép által értelmezett bytecode-ra.

@gelesztamás:
sorszámhúzógép: "Rábasztál, nincs sorszám, nyaralni van a személyzet. Sry bro"

@gelesztamás:
Azon gondolkoztam, hogy miért kell minden hivatalos intézménynek jópénzért windowst venni, amikor úgyis csak hibaüzeneteket nyom ki folyton?

@TCH:
Oké, ez igaz, de a gépi kód is sokkal trágyább lesz a ménkű sok ojjektumtól.

@kemi:
GTK-ban, meg Qt-ben is a GUI eleve OOP, meg a már említett képfeldolgozót az összes objektumstruktúrával együtt, sorról sorra fordítottam C#-ból C++-ba, és még úgy is 50-szer gyorsabb lett. A .NET/Java virtuális gép elég szűk keresztmetszet. Annál mindig gyorsabb lesz ugyanakkora komplexitás mellett.

@TCH:
Akkor hogy a fárasba jutottál be az épületbe?

unit Rnd2;

interface

procedure srnd2(seed: Longint);
function rand2: Longint;

implementation

var
	__seed0, __seed1, __seed2, __seed3: Longint;
	
function __rol(value: Longint; offset: Byte): Longint;
begin
	offset := offset and $1F;
	__rol := (value shl offset) or (value shr ($20 - offset));
end;

function __ror(value: Longint; offset: Byte): Longint;
begin
	offset := offset and $1F;
	__ror := (value shr offset) or (value shl ($20 - offset));
end;

procedure srnd2(seed: Longint);
begin
	__seed0 := seed;
	__seed1 := __seed0 xor $AAAAAAAA;
	__seed1 := __rol(__seed1 shr 11, __seed1);
	__seed1 := __seed1 xor (__seed1 shr 21);
	__seed2 := __seed0 xor $55555555;
	__seed2 := __ror(__seed2 shl 6, __seed2);
	__seed2 := __seed2 xor (__seed2 shr 22);
	__seed3 := (__seed2 shl 16) or (__seed1 shr 16);
end;

function rand2: Longint;
begin
	__seed1 := __rol(__seed1, 5);
	__seed2 := __ror(__seed2, 9);
	__seed0 := __rol(__seed0, 11);
	__seed0 := __seed0 xor __seed1;
	__seed0 := __seed0 xor  __rol(__seed1, 8) shl 11;
	__seed0 := __seed0 xor __ror(__seed2, 8) and 63;
	__seed0 := __seed0 xor __rol(__seed3, 8) shr 5;
	__seed0 := __ror(__seed0, 14);
	__seed0 := __seed0 xor __seed3;
	__seed1 := __seed0 xor __seed3;
	__seed2 := __seed0 xor __seed3;
	__seed3 := __ror(__seed3, __seed0);
	rand2 := __seed0;
end;

end.

program pas;
uses Crt, Rnd2, SysUtils, DateUtils;
var
	st: TSystemTime;
	table: Array[0..255] of Integer;
	i, j, k, r, temp: Integer;
    
begin
	DateTimeToSystemTime(Now, st);
	srnd2(st.MilliSecond);
	for i := 0 to 999 do
	begin
		for j := 0 to 999 do
		begin
			for k := 0 to 255 do table[k] := k;
			for k := 0 to 255 do
			begin
				r := rand2 and 255;
				temp := table[r];
				table[k] := temp;
			end;
		end;
	end;
end.

PS C:\Users\kemi242\Desktop\csc> measure-command {.\c.exe}


Days              : 0
Hours             : 0
Minutes           : 0
Seconds           : 20
Milliseconds      : 646
Ticks             : 206461548
TotalDays         : 0,000238960125
TotalHours        : 0,005735043
TotalMinutes      : 0,34410258
TotalSeconds      : 20,6461548
TotalMilliseconds : 20646,1548



PS C:\Users\kemi242\Desktop\csc> measure-command {.\pas.exe}


Days              : 0
Hours             : 0
Minutes           : 0
Seconds           : 23
Milliseconds      : 625
Ticks             : 236252006
TotalDays         : 0,000273439821759259
TotalHours        : 0,00656255572222222
TotalMinutes      : 0,393753343333333
TotalSeconds      : 23,6252006
TotalMilliseconds : 23625,2006



PS C:\Users\kemi242\Desktop\csc> measure-command {.\c_O3.exe}


Days              : 0
Hours             : 0
Minutes           : 0
Seconds           : 0
Milliseconds      : 938
Ticks             : 9389131
TotalDays         : 1,08670497685185E-05
TotalHours        : 0,000260809194444444
TotalMinutes      : 0,0156485516666667
TotalSeconds      : 0,9389131
TotalMilliseconds : 938,9131



PS C:\Users\kemi242\Desktop\csc> measure-command {.\pas_O3.exe}


Days              : 0
Hours             : 0
Minutes           : 0
Seconds           : 21
Milliseconds      : 641
Ticks             : 216414951
TotalDays         : 0,000250480267361111
TotalHours        : 0,00601152641666667
TotalMinutes      : 0,360691585
TotalSeconds      : 21,6414951
TotalMilliseconds : 21641,4951

@gelesztamás:
az épületben kell sorszámot húzni, és ott a váróterem, onnan hívogassák be az embert az ügyintéző elvtársakhoz

@kemi:
Konklúzió: Hát bizony a Pascalos verzió lassabb lett, és az optimalizáció is csak néhány másodpercet dobott rajta. De nembaj, itt az rnd2 Pascal implementációja, használjátok egész seggel.

@TCH:
Megmutatod a C teszt kódot is?