// Programm zufallszahlen erzeugt Pseudo-Zufallszahlen mit
// Hilfe der Funktionen ran1 und gasdev der Numerical Recipes.
// Als 'Seed' werden u.a. die Millisekunden der aktuellen Systemzeit 
// genutzt. Im zweiten Teil werden die Zufallszahlen in zwei
// Dateien gespeichert.
//
// 13.10.03, Thomas Maiwald

#include <stdio.h>
#include <stdlib.h>
#include "nr.h"
#include "nrutil.h"

// Unterschiedlicher Name des Time-Headers in Windows und Unix:
#ifdef WIN32
    #include <sys/timeb.h>
#else
    #include <sys/time.h>
#endif

int main()
{

    //------------------------------------------------------------------------------------
    //
    //         1. Teil
    //
    //------------------------------------------------------------------------------------

    int     N = 5;
    double  zufallszahl;
    long    idum;
    long millisekunden = 0;

    // Als erstes erzeugen wir Zufallszahlen, die den gleichen Seed besitzen:
    idum = -3; // negativer Wert (s. Numerical Recipes, Funktion ran1)
    printf("\nGleichfoermig verteilte Zufallszahlen aus (0,1)");
    printf("\nmit dem Start-Seed %d:\n\n",idum);
    for (int i=0; i<N; i++)
    {
        printf("Seed: %11d",idum);
        zufallszahl = ran1(&idum);      // Der Zeiger auf idum wird uebergeben, damit die
                                        // Funktion ran1 den Wert von idum ueberschreiben
                                        // kann, um im naechsten Aufruf eine neue 
                                        // Zufallszahl zu erzeugen. 
        printf("\tZufallszahl: %10f \n",zufallszahl);
    }
    idum = -3;
    printf("\nGleichfoermig verteilte Zufallszahlen aus (0,1)");
    printf("\nmit dem Start-Seed %d:\n\n",idum);
    for (int i=0; i<N; i++)
    {
        printf("Seed: %11d",idum);
        zufallszahl = ran1(&idum);
        printf("\tZufallszahl: %10f \n",zufallszahl);
    }

    // Um stets neue Zufallszahlen zu erhalten, benutzen wir die aktuelle
    // Systemzeit in Millisekunden als Seed. 
	// Es gibt unter Windows und Unix/Linux verschiedene Wege, um
    // an die Systemzeit zu gelangen. Wir fragen den Compiler mit #ifdef WIN32,
    // ob es sich um ein Windows-System handelt. Ansonsten benutzen wir den
    // Unix/Linux-Aufruf.
    #ifdef WIN32
        struct __timeb64 zeitWindows;           // WIN32-Zeit-Konstrukt erzeugen
        _ftime64( &zeitWindows );               // Zeit wird zugewiesen
        millisekunden = zeitWindows.millitm;    // Eigenschaft Millisekunden abfragen
    #else 
        struct timeval zeitUnix;                // UNIX-Zeit-Konstrukt erzeugen
        gettimeofday(&zeitUnix, NULL);	        // Zeit wird zugewiesen
        millisekunden = zeitUnix.tv_usec;       // Eigenschaft Millisekunden abfragen
	#endif

    idum = -millisekunden;                      // Negativer Seed (s. ran1)

    printf("\nGleichfoermig verteilte Zufallszahlen aus (0,1)");
    printf("\nmit dem Start-Seed %d:\n\n",idum);
	for(int i=0; i<N; i++)
	{
        printf("Seed: %11d",idum);
		zufallszahl = ran1(&idum);		
        printf("\tZufallszahl: %10f \n",zufallszahl);
	}

    // Nun wollen wir Gaussverteilte Zufallszahlen erzeugen. Dies geschieht mit der
    // Funktion gasdev.

	idum = -millisekunden;			      
    printf("\nGaussverteilte Zufallszahlen aus N(0,1) \nmit dem Start-Seed %d:\n\n",idum);
	for(int i=0; i<N; i++)
	{
        printf("Seed: %11d",idum);
		zufallszahl = gasdev(&idum);		
        printf("\tZufallszahl: %10f \n",zufallszahl);
	}

    //------------------------------------------------------------------------------------
    //
    //     2. Teil
    //
    //------------------------------------------------------------------------------------

    // Nun sollen die Zufallszahlen in zwei Dateien ran.txt und gauss.txt gespeichert
    // werden, damit wir ihre Verteilung beispielsweise mit Gnuplot betrachten koennen:

    // Zufallszahlen in Vektoren speichern:
    
    N = 300;
    double* ran   = new double[N];
    double* gauss = new double[N];

    for(int i=0; i<N; i++)
    {
        ran[i]   = ran1(&idum);
        gauss[i] = gasdev(&idum);
    }

    // Vektoren in Dateien speichern

    FILE* datei_ptr1;                       // Ein FILE-Pointer wird angelegt.
    FILE* datei_ptr2;
    datei_ptr1 = fopen("ran.txt","w+");    
    datei_ptr2 = fopen("gauss.txt","w+");   // Datei wird zum Schreiben geoeffnet.
                                            // w+ steht fuer: Datei schreiben und falls 
                                            // bereits vorhanden Datei ueberschreiben.

    for(int i=0; i<N; i++)
    {
        fprintf(datei_ptr1,"%10f \n",ran[i]);
        fprintf(datei_ptr2,"%10f \n",gauss[i]);
    }

    fclose(datei_ptr1);
    fclose(datei_ptr2);
    

    return 0;
}