//Template fuer numerische Loesung von "Maximum-Likelihood-Sch ̈tzung fur Normalverteilungen"

//Die folgende Konstante gibt die Groesse der Stichprobe an.
static const int N = 10;

//Die negative Log-Likelihood Funktion haengt ab von der Groesse der Stichprobe,
//sowie von der Standardabweichung und vom Mittelwert.
//Im 2D Fall werden Mittelwert und Standardabweichung als Parameter x uebergeben.
double NegativeLL2D(double* x, double par[N]){
  float xx = x[0];
  float yy = x[1];
  ...
  return ...;
}

//1D Fall
double NegativeLLMean(double*x, double par[N+1]){
  float xx = x[0];
  return ...;
}


int ex13(float mean = 0., float sigma = 2){
  //Zuerst wird die Stichprobe generiert.
  float probe[N];

  //Zuerst wird nur eine Stichprobe fuer den graphischen Fall behandelt.
  for(int ii = 0; ii < N; ii++){
    probe[ii] = gRandom->Gaus(mean, sigma);
  }

  //Versuchen Sie sich an einer der folgenden Optionen. Die andere kommentieren Sie am besten aus.
  // *
  //Option 1: 2D Fall
  //Der analytische Teil sollte bereits zeigen, dass der Schaetzer fuer den Mittelwert nicht
  //abhaengig von der Schaetzung fuer die Breite ist. (Umgekehrt gilt das nicht und die Breite kann nicht
  //ohne Schaetzung des Mittelwerts geschaetzt werden.)
  //Wer moechte kann dennoch eine 2D Funktion erstellen.
  TF2* myNegativeLL2D = ...
  for(int ii =0; ii < N; ii++){
    myNegativeLL2D->SetParameter(ii, probe[ii]);
  }
  
  //Zur graphischen Analyse kann ein 2D Lego-Plot erstellt werden:
  myNegativeLL2D->SetNpx(100);
  myNegativeLL2D->SetNpy(100);
  myNegativeLL2D->Draw("lego");

  //Die Funktionalitaet, um das 2D Minimum zu bekommen ist
  //http://root.cern.ch/root/html/TF2.html#TF2:GetMinimumXY
  double minX = 100;
  double minY = 100;
  myNegativeLL2D->GetMinimumXY(minX, minY);
  cout << minX << ", " << minY << " This is the Minimum " <<endl;

  //Nun die Methode mit parametrischem Bootstrapping.
  //Man auch mehr bins und eine groessere Zahl von Versuchen benutzen, aber diese Methode ist sehr rechenaufwaendig.
  TH1F* myhMean = ...
  TH1F* myhSigma= ...
  for (int ii = 0; ii < 100; ii++){
    for (int jj = 0; jj < N; jj++){
      myNegativeLL2D->SetParameter(jj, gRandom->Gaus(mean, sigma));
      myNegativeLL2D->GetMinimumXY(minX, minY);
      myhMean->Fill(minX);
      myhSigma->Fill(minY);
    } 
  }
  myhMean->SaveAs("Mean.root");
  myhSigma->SaveAs("Sigma.root");
  // */ //----------------------------------------------------------------------------------

  /// *
  //Option 2: 1D Fall
  TF1* myNegativeLL1D = ...

  //Die ersten N Parameter sind wiederum die Stichprobe.
  for(int ii =0; ii < N; ii++){
    myNegativeLL1D->SetParameter(ii, probe[ii]);
  }
  //Der N. Parameter wird auf irgendeinen Wert fuer die Standardabweichung gesetzt.
  myNegativeLL1D->SetParameter(...);

  myNegativeLL1D->Draw();
  
  //Herausfinden des Minimums im 1D Fall:
  cout << myNegativeLL1D->GetMinimumX() << " This is the Minimum " << endl;
  
  //Kommen wir nun zum parametrischen Bootstrapping.
  TH1F* myhMu = ...
  for (int ii = 0; ii < 100; ii++){
    for (int jj = 0; jj < N; jj++){
      myNegativeLL1D->SetParameter(jj, gRandom->Gaus(mean, sigma));
      myhMu->Fill(myNegativeLL1D->GetMinimumX());
    } 
  }
  myhMu->SaveAs("Mu.root");
  // */

  return 0;
}