So erstellen Sie einen Assistenten

 

Zusammenfassung

Ein Assistent ist eine grafische Benutzeroberfläche, die eine Reihe von Dialogfeldern enthält, die den Anwender Schritt für Schritt durch einen Prozess führen. Mit einem Assistenten werden komplexe Aufgaben einfacher durchführbar. Origin enthält mehrere Klassen in Origin C, mit denen Anwender einen Assistenten entwickeln können. Das Dialogfeld für jeden Schritt in einem Assistenten kann mit Hilfe einer X-Funktion erstellt werden.

In diesem Beispiel kann der Assistent einen Test auf Normalverteilung und einen t-Test bei einer Stichprobe für Daten in einer Spalte durchführen. Das Ergebnis des Tests auf Normalverteilung kann in einem t-Test bei einer Stichprobe geteilt werden.

Hinweis: Für dieses Tutorial benötigen Sie das Developer Kit.

Origin-Version mind. erforderlich: 8.1 SR0

Was Sie lernen werden

  • Erstellen einer X-Funktion
  • Teilen einer Variablen oder eines Datenbereichs in unterschiedlichen Schritten
  • Aufrufen einer X-Funktion in OriginC
  • Erstellen eines Assistenten

Erstellen von vier X-Funktionen

  1. Wählen Sie Hilfsmittel: X-Funktionen erstellen oder drücken Sie F10, um das Dialogfeld X-Funktionen erstellen zu öffnen.
  2. Fügen Sie die Variablen folgendermaßen ein und speichern Sie die X-Funktion als "StatTest" im Anwenderdateiordner, Anwenderdateien\X-Functions\Statistics\Hypothesis Testing.
    Image:How_to_Create_a_Wizard_xf1.png
  3. Klicken Sie auf die Schaltfläche Neuer X-Funktionen-Assistent. Fügen Sie die Variablen folgendermaßen ein und speichern Sie die X-Funktion als "StatTestWizGoal" im Anwenderdateiordner, Anwenderdateien\X-Functions\Statistics\Hypothesis Testing.
    Image:How_to_Create_a_Wizard_xf2.png
  4. Klicken Sie auf die Schaltfläche Neuer X-Funktionen-Assistent. Fügen Sie die Variablen folgendermaßen ein und speichern Sie die X-Funktion als "NormalityTest" im Anwenderdateiordner, Anwenderdateien\X-Functions\Statistics\Hypothesis Testing.
    Image:How_to_Create_a_Wizard_xf3.png
  5. Klicken Sie auf die Schaltfläche Neuer X-Funktionen-Assistent. Fügen Sie die Variablen folgendermaßen ein und speichern Sie die X-Funktion als "OnetTest" im Anwenderdateiordner, Anwenderdateien\X-Functions\Statistics\Hypothesis Testing.
    Image:How_to_Create_a_Wizard_xf4.png

Beachten Sie, dass die X-Funktionen NormalityTest und OnetTest die gleiche Variable "prob" besitzen, die eine geteilte Variable darstellt und in der Quelldatei deklariert wird.

Aktualisieren der Eigenschaften der X-Funktion in der Baumansicht

  1. Öffnen Sie die X-Funktion StatTest. Klicken Sie auf die Schaltfläche Baumansicht Image:TreeView.png, um die Baumansicht zu öffnen. Nehmen Sie in der Baumansicht folgende Einstellungen vor.
    Image:How_to_Create_a_Wizard_xf1s.png
  2. Klicken Sie auf die Schaltfläche OXF-Datei speichern, um die X-Funktion zu speichern.
  3. Öffnen Sie die X-Funktion StatTestWizGoal, NormalityTest und OnetTest jeweils im Dialogfeld X-Funktionen erstellen. Klicken Sie auf die Schaltfläche Baumansicht Image:TreeView.png, geben Sie "Select Wizard Goal", "Normality Test" und "One-Sample t-test" im Bearbeitungsfeld Beschreibung in der jeweiligen Baumansicht der X-Funktion ein. Dies wird dann in den Dialogfeldern gezeigt.

Erstellen von Dateien für den Assistenten

  • Klicken Sie auf die Schaltfläche Code Builder in der Symbolleiste Standard. Klicken Sie im Code Builder auf die Schaltfläche Öffnen . Wählen Sie im Dialogfeld Neue Datei die Option H File, klicken Sie auf die Schaltfläche Durchsuchen und wählen Sie den Anwenderdateiordner, Anwenderdateien\OriginC, als den Speicherort der neuen Headerdatei. Geben Sie StatTestWiz im Bearbeitungsfeld Dateiname ein. Klicken Sie auf OK , um das Dialogfeld zu schließen.

Fügen Sie das folgende Skript in die Datei StatTestWiz.h ein.

#ifndef __STAT_TEST_WIZ_H__
#define __STAT_TEST_WIZ_H__
 
#include <..\OriginLab\XFWiz.h> 
#include <..\OriginLab\XFCore.h> 
#include <..\OriginLab\XFWizard_utils.h> 
 
class StatTestWizCore : public XFCore
{
public:
   StatTestWizCore();
 
public:       
   void ChangeGoal(int nGoal);
   DataRange GetRange();      
 
   int nStep;
protected:
 
};
 
int stat_test_run_wiz_nodlg(LPCSTR lpcszThemeName = NULL, const XFWizTheme *pXFWizTheme 
= NULL, const XFWizInputOutputRange *pXFWizIO = NULL, DWORD dwOPUID = 0);
 
int stat_test_open_wiz_dlg(LPCSTR lpcszThemeName = NULL, const XFWizTheme *pXFWizTheme 
= NULL, const XFWizInputOutputRange *pXFWizIO = NULL, DWORD dwOPUID = 0);
 
#endif     //__STAT_TEST_WIZ_H__

Klicken Sie auf die Schaltfläche Speichern, um die Datei StatTestWiz.h zu speichern.

  • Wiederholen Sie die gleiche Operation, um eine neue C-Datei zu erstellen, StatTestWiz.c.

Fügen Sie das folgende Skript in die Datei StatTestWiz.c ein.

///////////////////////////////////////////////////////////////////////////////////
#include <..\OriginLab\XFWizManager.h> 
 
#include <..\OriginLab\WizOperation.h> 
#include <..\OriginLab\XFWizNavigation.h> 
 
#include <..\OriginLab\XFWizScript.h> 
#include <..\OriginLab\XFWizDlg.h> 
 
///////////////////////////////////////////////////////////////////////////////////
// Include your own header files here.
#include "StatTestWiz.h" 
 
enum
{
        GOAL_ALL = 0,
        GOAL_SIMPLE,
};
 
//Names of three X-Functions
#define STR_STEP_GOAL      "StatTestWizGoal"
#define STR_STEP_Normal    "NormalityTest"
#define STR_STEP_TTest "OnetTest"
 
//Names of steps shown in the wizard.
#define STR_LABEL_STEP_GOAL        "Goal"
#define STR_LABEL_STEP_Normal      "Normality Test"
#define STR_LABEL_STEP_TTest       "One-Sample t-test"
 
///////////////////////////////////////////////////////////////////////////////////
//Class StatTestWizTheme
class StatTestWizTheme : public XFWizTheme
{
public:
   StatTestWizTheme();
};
 
//Name of the variable prob shared by X-Functions NormalityTest and OnetTest
#define STR_GETN_VAR_SHARED_NProb "prob"
 
StatTestWizTheme::StatTestWizTheme()
:XFWizTheme()
{
   m_saSharedList.Add(STR_GETN_VAR_SHARED_NProb); //Add the shared variable
}
 
///////////////////////////////////////////////////////////////////////////////////
class StatTestWizInputOutputRange : public XFWizInputOutputRange
{
};
 
///////////////////////////////////////////////////////////////////////////////////
//Class StatTestWizManager
 
#define STR_CLASS_NAME_TEST        "StatTestWiz"
#define TEST_VERSION_NUMBER        1.0
 
class StatTestWizManager : public XFWizManager
{
public:
   StatTestWizManager(LPCSTR lpcszThemeName = NULL, const XFWizTheme *pXFWizTheme 
= NULL, const XFWizInputOutputRange *pXFWizIO = NULL, DWORD dwUIDOp = 0);
 
protected:
   virtual double GetVersion() { return TEST_VERSION_NUMBER; }       
   virtual XFCore* CreateXFCore() { return new StatTestWizCore; }
   virtual XFWizTheme*        CreateXFWizTheme() { return new StatTestWizTheme; }
   virtual XFWizInputOutputRange* CreateXFWizInputOutputRange()
             { return new StatTestWizInputOutputRange; }
   virtual string GetClassName() { return STR_CLASS_NAME_TEST; }
};
 
StatTestWizManager::StatTestWizManager(LPCSTR lpcszThemeName, const XFWizTheme 
*pXFWizTheme, const XFWizInputOutputRange *pXFWizIO, DWORD dwUIDOp) 
: XFWizManager(lpcszThemeName, pXFWizTheme, pXFWizIO, dwUIDOp)
{
   StringArray saMapXFNames = {STR_STEP_GOAL, STR_STEP_Normal, STR_STEP_TTest};
   StringArray saMapXFLabels = {STR_LABEL_STEP_GOAL, STR_LABEL_STEP_Normal, 
                                 STR_LABEL_STEP_TTest};
   m_saMapXFNames = saMapXFNames;
   m_saMapXFLabels = saMapXFLabels;
   ASSERT( m_saMapXFNames.GetSize() == m_saMapXFLabels.GetSize() );
 
   StringArray saMapXFNames = {STR_STEP_GOAL, STR_STEP_Normal, STR_STEP_TTest};
   m_saDefaultXFNames = saDefaultXFNames;
 
   m_strRunDlgName = _L("Stat Test");
}
 
///////////////////////////////////////////////////////////////////////////////////
//Class StatTestWizCore
 
StatTestWizCore::StatTestWizCore()
:XFCore()
{
   StringArray vsXFsRecalculateShown = {STR_STEP_GOAL};
   m_vsXFsRecalculateShown = vsXFsRecalculateShown;
   nStep = GOAL_ALL;
}
 
//Select steps in the Goal Step
void StatTestWizCore::ChangeGoal(int nGoal)
{
   XFWizNavigation *pXFWizNavg = (XFWizNavigation *)GetXFWizNavigation();
   ASSERT(pXFWizNavg);
 
   nStep = nGoal;
 
   if ( pXFWizNavg )
   {
      StringArray saXFNames;
      saXFNames.Add(STR_STEP_GOAL);
      switch (nGoal)
      {
      case GOAL_ALL:
         saXFNames.Add(STR_STEP_Normal);
         saXFNames.Add(STR_STEP_TTest);
         break;
      case GOAL_SIMPLE:
         saXFNames.Add(STR_STEP_TTest);
         break;
      }
 
      pXFWizNavg->SetSteps(saXFNames);
 
   }
}
 
//Get input DataRange in the Goal Step.
DataRange StatTestWizCore::GetRange()
{
   XFWizNavigation *pXFWizNavg = (XFWizNavigation *)GetXFWizNavigation();
   XFWizInputOutputRange* pIORange = pXFWizNavg->GetXFWizInputOutputRange();
 
   DataRange drInput;
   if(!pIORange)
   {
      error_report("Fail to get io ranges!");
      return drInput;
   }
 
   Array<DataRange&> drs;
   //Get input DataRange.
   if(!pIORange->Get(&drs, STR_STEP_GOAL, true))
   {
      error_report("Fail to get range from WizCore!");
      return drInput;
   }
 
   drInput = drs.GetAt(0);
 
   return drInput;
}
 
///////////////////////////////////////////////////////////////////////////////////
 
int stat_test_run_wiz_nodlg(LPCSTR lpcszThemeName, const XFWizTheme *pXFWizTheme, const 
XFWizInputOutputRange *pXFWizIO, DWORD dwOPUID)
{
   TEMPLATE_run_wiz_nodlg(StatTestWizManager, lpcszThemeName, pXFWizTheme, pXFWizIO, dwOPUID)
}
 
int stat_test_open_wiz_dlg(LPCSTR lpcszThemeName, const XFWizTheme *pXFWizTheme, const  
XFWizInputOutputRange *pXFWizIO, DWORD dwOPUID)
{
   TEMPLATE_open_wiz_dlg(StatTestWizManager, lpcszThemeName, pXFWizTheme, pXFWizIO, dwOPUID) 
}
 
int stat_test_run_wiz(UINT msg, const XFWizTheme *pXFWizTheme, const 
XFWizInputOutputRange *pXFWizIO, DWORD dwOPUID, int nExeMode)
{
   TEMPLATE_run_wiz(StatTestWizManager, msg, pXFWizTheme, pXFWizIO, dwOPUID, nExeMode)
}

Klicken Sie auf die Schaltfläche Speichern, um die Datei StatTestWiz.h zu speichern.

Beachten Sie, das die X-Funktion StatTest vor der StatTestWiz.c kompiliert werden sollte, damit sich die in StatTestWiz.c enthaltenen Dateien im Arbeitsbereich befinden, bis die X-Funktion StatTest kompiliert ist. StatTestWiz.h ist in der X-Funktion StatTest enthalten. StatTestWiz.c wird automatisch kompiliert, wenn die X-Funktion StatTest kompiliert wird.

Hinzufügen von Skript für X-Funktionen

Script für X-Funktion StatTest

Klicken Sie im Dialogfeld X-Funktionen erstellen auf die Schaltfläche Öffnen und öffnen Sie die X-Function StatTest. Klicken Sie auf X-Funktion in Code Builder bearbeiten und fügen Sie das folgende Skript hinzu.

  • Headerdateien einschließen
#include <..\OriginLab\XFWiz.h> 
#include <..\OriginLab\WizOperation.h> 
#include <..\OriginLab\XFCore.h> 
#include <..\OriginLab\XFWizNavigation.h> 
#include <..\OriginLab\XFWizManager.h> 
#include <..\OriginLab\XFWizScript.h> 
#include <..\OriginLab\XFWizDlg.h> 
 
#include <..\OriginLab\XFWizard_utils.h> 
 
#include <..\OriginLab\WksOperation.h> 
 
#include <event_utils.h> 
 
#include "StatTestWiz.h"
  • StatTest()

Fügen Sie den Funktionskörper hinzu, der den Dialogmodus festlegt.

if( script )
   stat_test_run_wiz_nodlg(tn);
else
   stat_test_open_wiz_dlg(tn);
  • StatTest_before_execute()

Fügen Sie den Funktionskörper hinzu, mit dem bestimmt werden kann, ob dieser Dialog vor dem Öffnen des Assistenten geöffnet werden soll.

   nRet = XFEVT_PROCEED_NO_DLG;

Klicken Sie auf die Schaltfläche Kompilieren, um die Datei zu kompilieren. Klicken Sie dann auf die Schaltfläche Zurück zum Dialog, um zum Dialogfeld X-Funktionen erstellen zurückzukehren. Klicken Sie im Dialog X-Funktionen erstellen auf die Schaltfläche OXF-Datei speichern, um die X-Funktion zu speichern.

Skript für X-Funktion StatTestWizGoal

Öffnen Sie die X-Funktion StatTestWizGoal. Klicken Sie auf X-Funktion in Code Builder bearbeiten und fügen Sie das folgende Skript hinzu.

  • Headerdateien einschließen
#include "StatTestWiz.h"
  • Hinzufügen der Statischen Funktion _check_input()

Diese Funktion wird verwendet, um zu prüfen, ob der Eingabedatenbereich eine einzelne Spalte ist.

static bool _check_input(const TreeNode trGetN, string& strErr)
{
   TreeNode trRange = trGetN.input;
   DataRange drInput;
 
   drInput.Create(trRange.strVal);  
 
   if( drInput.GetNumRanges() == 0 )
   {
      strErr = "Input can't be empty, and it should be a valid column.";
      return false;
   }
   else
   {
      if( drInput.GetNumRanges() == 1)
      {
         Worksheet wksInput;
         int nC1, nC2;
         drInput.GetRange(wksInput, nC1, nC2);
         if( nC1 == nC2 )
            return true;
      }
 
          strErr = "Please select one column.";
          return false;
   }       
}
  • StatTestWizGoal_event1()

Fügen Sie den Funktionskörper hinzu, der das Dialogfeld aktualisiert.

   StatTestWizCore* pstatwc = (StatTestWizCore*)get_xf_core_handler(trGetN);
   ASSERT(pstatwc);
 
   //Update the Wizard page.
   if ( 0 == lstrcmp(lpcszNodeName, "goal") )
      pstatwc->ChangeGoal(trGetN.goal.nVal);
 
 
   //Error message is shown at the bottom of the dialog, 
   //and OK button is disenabled for incorrect choice of DataRange.
   bOKEnable = _check_input(trGetN, strErrMsg);
 
   return false;

Klicken Sie auf die Schaltfläche Kompilieren, um die Datei zu kompilieren. Klicken Sie dann auf die Schaltfläche Zurück zum NLSF, um zum Dialogfeld X-Funktionen erstellen zurückzukehren, und klicken Sie auf OXF-Datei speichern, um die X-Funktion zu speichern.

Skript für X-Funktion NormalityTest

Öffnen Sie die X-Funktion NormalityTest. Klicken Sie auf X-Funktion in Code Builder bearbeiten und fügen Sie das folgende Skript hinzu.

  • Headerdateien einschließen
#include "StatTestWiz.h" 
 
#include <XFbase.h>
  • Hinzufügen einer statischen Funktion _update_GUI()

Diese Funktion wird verwendet, um die Bearbeitungsfelder des Dialogfelds für den Test auf Normalverteilung zu aktualisieren.

static void _update_GUI(TreeNode& trGetN)
{
   vector vRes;
   vRes = _norm_test(trGetN.nXFCorePointer.nVal, trGetN.type.nVal);
 
   trGetN.stat.dVal = vRes[0];
   trGetN.df.dVal = vRes[1];
   trGetN.prob.dVal = vRes[2];
}
  • Hinzufügen einer statischen Funktion _update_strErr()

Diese Funktion wird verwendet, um die unten im Dialogfeld gezeigte Zeichenkette zu aktualisieren.

static void _update_strErr(const TreeNode tr, string& strErr)
{
   if(tr.prob.dVal >= 0,05 && tr.prob.dVal <= 1)
      strErr = "At the 0,05 level, the data was significantly drawn from a 
            normally distributed population.";
   else if(tr.prob.dVal < 0,05 && tr.prob.dVal >= 0)
      strErr = "At the 0,05 level, the data was not significantly drawn from a 
            normally distributed population.";
   else            
      strErr = "There is not enough information to draw a conclusion.";
}

Beachten Sie, dass die Zeichenkette in zwei Zeilen geteilt ist, die auf der Seite gezeigt werden. Im Skript sollte ein einzeiliger Befehl enthalten sein.

  • Hinzufügen einer statischen Funktion _norm_test()

Diese Funktion wird verwendet, um den Test auf Normalverteilung mit Hilfe verwandter X-Funktionen durchzuführen.

static vector _norm_test(const int nXFCorePointer, const int nType)
{
   StatTestWizCore* pstatwc = (StatTestWizCore*)get_xf_core_handler(nXFCorePointer);
   ASSERT(pstatwc);
 
   vector vRes(3);
   vRes[2] = -1;
   DataRange drInput;
   drInput = pstatwc->GetRange[];
   if( !drInput )
      return vRes;
 
   vector<string> vsXFName = {"swtest","kstest","lillietest"};
   XFBase xfNorm(vsXFName[nType]);
   if( !xfNorm.SetArg)"irng", drInput) )
   {
      error_report("Failed to set argument image type");
      return vRes;
   }
   if( !xfNorm.SetArg("stat", vRes[0]) )
   {
      error_report("Failed to set argument image type");
      return vRes;
   }
   if( !xfNorm.SetArg("df", vRes[1]) )
   {
       error_report("Failed to set argument image type");
       return vRes;
   }
   if( !xfNorm.SetArg("prob", vRes[2]) )
   {
       error_report("Failed to set argument image type");   
       return vRes;
   }
 
   if( !xfNorm.Evaluate() )
   {
      error_report("Failed to evaluate the stats X-Function.");
      return vRes;
   }
 
   return vRes;
}
  • NormalityTest()

Aktualisieren Sie den Funktionskörper, der das Ergebnis in ein Arbeitsblatt exportiert, wenn auf die Schaltfläche Weiter geklickt wird.

   DataRange drInput;
   StatTestWizCore* pstatwc = (StatTestWizCore*)get_xf_core_handler(nXFCorePointer);
   ASSERT(pstatwc);
   drInput = pstatwc->GetRange[];
 
   if( !drInput )
      return;
   string strBook, strSheet;
   if(!drInput.GetBookSheet(strBook, strSheet))
   {
      error_report("Workbook and worksheet names can't be obtained.");
      return;
   }
   WorksheetPage wpData(strBook);
 
   int nLayer = wpData.AddLayer("Normality Test");
 
   if(nLayer >= 0)
   {
      Worksheet wksRes = wpData.Layers(nLayer);
      vector<string> vsTypeName = {"Shapiro-Wilk","Kolmogorov-Smirnov","Lilliefors"};
      vector<string> vsNProb = {"Prob<W", "Prob>D", "Prob>D"};
      vector<string> vsParaName = {"Statistic", "DF", ""};
      vsParaName[2] = vsNProb[type];
 
      vector vRes;
      vRes = _norm_test[nXFCorePointer, type];
 
      wksRes.Columns(1).SetLongName(vsTypeName[type]);
      for(int ii=0; ii<3; ii++) 
      {
         wksRes.SetCell(ii, 0, vsParaName[ii], false);
         wksRes.SetCell(ii, 1, vRes[ii]);
      }
   }
   else
   {
      error_report("New worksheet can't be created.");
   }
  • NormalityTest_event1()

Aktualisieren Sie den Funktionskörper, der die Ergebnisse im Dialogfeld aktualisiert, sobald die Methode des Tests auf Normalverteilung gewechselt wird. Zeichenketten unten im Dialogfeld werden ebenfalls aktualisiert.

   _update_GUI(trGetN);
   _update_strErr(trGetN, strErrMsg);      
 
   return true;
  • NormalityTest_before_execute()

Aktualisiert den Funktionskörper, wodurch die Bearbeitungsfelder für Ergebnisse ausgegraut werden, und zeigt das Ergebnis im Dialogfeld.

   trGetN.stat.Enable = false;
   trGetN.df.Enable = false;
   trGetN.prob.Enable = false;

Klicken Sie auf die Schaltfläche Kompilieren, um die Datei zu kompilieren. Klicken Sie dann auf die Schaltfläche Zurück zum NLSF, um zum Dialogfeld X-Funktionen erstellen zurückzukehren, und klicken Sie auf die Schaltfläche OXF-Datei speichern, um die X-Funktion zu speichern.

Skript für X-Funktion OnetTest

Öffnen Sie die X-Funktion OnetTest. Klicken Sie auf X-Funktion in Code Builder bearbeiten und fügen Sie das folgende Skript hinzu.

  • Headerdateien einschließen
#include "StatTestWiz.h" 
 
#include <XFbase.h>
  • Zeichenketten definieren
const vector<string> vsNull = {"Mean = ","Mean <= ","Mean >= "};
const vector<string> vsAlter = {"Mean <> ","Mean > ","Mean < "};
const vector<string> vsAcceptNull = {"Not significantly different from","Not 
significantly greater than","Not significantly less than"};
const vector<string> vsRejectNull = {"significantly different from","significantly 
greater than","significantly less than"};
const vector<string> vsProb = {"Prob>|t|", "Prob>t", "Prob<t"};
  • Hinzufügen der statischen Funktion _update_null()

Diese Funktion wird verwendet, um das Bearbeitungsfeld Null zu aktualisieren.

static void _update_null(TreeNode& trGetN, bool bMean = false)
{
   string strNull;
 
   strNull = vsNull[trGetN.tail.nVal] + ftoa(trGetN.mean.dVal);
   trGetN.null.strVal = strNull;
 
   if(bMean)
   {
      string strAlter = vsAlter[0] + ftoa(trGetN.mean.dVal) + "|";
      strAlter = strAlter + vsAlter[1] + ftoa(trGetN.mean.dVal) + "|";
      strAlter = strAlter + vsAlter[1] + ftoa(trGetN.mean.dVal);
 
      trGetN.tail.SetAttribute(STR_COMBO_ATTRIB, strAlter);
   }
}
  • Hinzufügen der statischen Funktion _check_sig_level()

Diese Funktion wird verwendet, um den Wert im Bearbeitungsfeld Signifikanzniveau zu überprüfen.

static bool _check_sig_level(TreeNode& trGetN, string& strErr)
{
   if( trGetN.siglevel.dVal > 0 && trGetN.siglevel.dVal < 1 )
   {
      return true;
   }
   else
   {
      strErr = "Significance Level should be between 0 and 1,";
      return false;
   }
}
  • Hinzufügen einer statischen Funktion _update_strErr()

Diese Funktion wird verwendet, um die Zeichenkette für die Schlussfolgerung des t-Tests unten zu definieren, basierend auf dem P-Wert.

static void _update_strErr(const TreeNode tr, string& strErr)
{   
   if(tr.tprob.dVal >= tr.siglevel.dVal && tr.tprob.dVal <= 1)
      strErr.Format("Null Hypothesis is %s%s.\r\nAlternative Hypothesis is %s%s.
         At the %s level, the population mean is %s the test mean(%s).",          
         vsNull[tr.tail.nVal], ftoa(tr.mean.dVal), vsAlter[tr.tail.nVal], ftoa(tr.mean.dVal),      
         ftoa(tr.siglevel.dVal), vsAcceptNull[tr.tail.nVal], ftoa(tr.mean.dVal) );
   else if(tr.tprob.dVal < tr.siglevel.dVal && tr.tprob.dVal >= 0)
      strErr.Format("Null Hypothesis is %s%s.\r\nAlternative Hypothesis is %s%s.
         At the %s level, the population mean is %s the test mean(%s).", 
         vsNull[tr.tail.nVal], ftoa(tr.mean.dVal), vsAlter[tr.tail.nVal], ftoa(tr.mean.dVal),
         ftoa(tr.siglevel.dVal), vsRejectNull[tr.tail.nVal], ftoa(;tr.mean.dVal); );
   else     
      strErr = "There is not enough information to draw a conclusion.";
}

Beachten Sie, dass der Befehl in mehrere Zeilen geteilt ist, gezeigt auf der Seite. Im Skript sollte ein einzeiliger Befehl enthalten sein.

  • Hinzufügen einer statischen Funktion _update_GUI()

Diese Funktion wird verwendet, um die Bearbeitungsfelder für die Ergebnisse im Dialogfeld zu aktualisieren.

static void _update_GUI(TreeNode& trGetN)
{  
   vector vRes;
   vRes = _one_sample_t_test(trGetN.nXFCorePointer.nVal, trGetN.mean.dVal, trGetN.tail.dVal, trGetN.siglevel.dVal);
 
   trGetN.stat.dVal = vRes[0];
   trGetN.df.dVal = vRes[1];
   trGetN.tprob.dVal = vRes[2];
   trGetN.lcl.dVal = vRes[4];
   trGetN.ucl.dVal = vRes[5];   
}
  • Hinzufügen einer statischen Funktion _one_sample_t_test()

Diese Funktion wird verwendet, um einen t-Test bei einer Stichprobe mit Hilfe einer X-Funktion durchzuführen.

static vector _one_sample_t_test(const int nXFCorePointer, const double dMean, const int nTail, const double dSiglevel)
{
   DataRange drInput;
   StatTestWizCore* pstatwc = (StatTestWizCore*)get_xf_core_handler(nXFCorePointer);
   ASSERT(pstatwc);
 
   vector coeff(6);
   vRes[2] = -1;
   drInput = pstatwc->GetRange[];
   if( !drInput )
      return vRes;
 
   vRes[3] = 100 - 100*dSiglevel;
 
   XFBase xfTTest("ttest1");
 
   if( !xfTTest.SetArg("irng", drInput) ) 
   {
      error_report("Failed to set argument irng");
      return vRes;
   }
   if( !xfTTest.SetArg("mean", dMean) )
   {
      error_report("Failed to set argument mean");
      return vRes;
   }
   if( !xfTTest.SetArg("tail", nTail) )
   {
      error_report("Failed to set argument tail");
      return vRes;
   }
   if( !xfTTest.SetArg("alpha", dSiglevel) )
   {
      error_report("Failed to set argument alpha");
      return vRes;
   }
 
   if( !xfTTest.SetArg("stat", vRes[0]) ) 
   {
      error_report("Failed to set argument stat");
      return vRes;
   }
   if( !xfTTest.SetArg("df", vRes[1]) ) 
   {
       error_report("Failed to set argument df");
       return vRes;
   }
   if( !xfTTest.SetArg("prob", vRes[2]) )
   {
       error_report("Failed to set argument prob");
       return vRes;
   }
   if(; !xfTTest.SetArg("lcl", vRes[4]) )
   {
       error_report("Failed to set argument lcl");
       return vRes;
   }
   if( !xfTTest.SetArg("ucl", vRes[5]) ) 
   {
       error_report("Failed to set argument ucI");
       return vRes;
   }
 
   if( !xfTTest.Evaluate() )
   {
      error_report("Failed to evaluate the ttest1 X-Function.");
      return vRes;
   }
 
   return vRes;
}
  • OnetTest()

Aktualisieren Sie den Funktionskörper, der das Ergebnis in ein Arbeitsblatt exportiert, wenn Sie auf die Schaltfläche Fertigstellen klicken.

   DataRange drInput;
   StatTestWizCore* pstatwc = (StatTestWizCore*)get_xf_core_handler(nXFCorePointer);
   ASSERT(pstatwc);
 
   drInput = pstatwc->GetRange[];
   if( !drInput )
      return;
 
   string strBook, strSheet;
   if(!drInput.GetBookSheet(strBook, strSheet))
   {
      error_report("Workbook and worksheet names can't be obtained.");
      return;
   }
   WorksheetPage wpData(strBook);
 
   int nLayer = wpData.AddLayer("One-Sample t-test");
 
   if(nLayer >= 0)
   {
      Worksheet wksRes = wpData.Layers(nLayer);
 
      vector<string> vsParaName = {"t Statistic", "DF","", "Conf. Levels in %", "Lower Limits", "Lower Limits"};
      vsParaName[2] = vsProb]tail];
 
      vector vRes;
      vRes = _one_sample_t_test(nXFCorePointer, mean, tail, siglevel);
 
      wksRes.SetSize(-1, 4);
      wksRes.Columns(0).SetLongName("Test Statistics");
      string strNull = "Null Hypothesis is " + vsNull[tail] + ftoa(mean);
      wksRes.Columns(1).SetLongName(strNull);
      wksRes.Columns(3).SetLongName("Confidence Intervals for Mean");
      for(int ii=0; ii<3; ii++) 
      {
         wksRes.SetCell(ii, 0, vsParaName[ii], false);
         wksRes.SetCell(ii, 1, vRes[ii]);
 
         wksRes.SetCell(ii, 2, vsParaName[ii + 3], false);
         wksRes.SetCell(ii, 3, vRes[ii + 3]);
      }     
   }
   else
   {
      error_report("New worksheet can't be created.");
   }
  • OnetTest_event1()

Aktualisieren Sie den Funktionskörper, wodurch die Ergebnisse aktualisiert und eine Schlussfolgerung unten im Dialogfeld basierend auf dem Ergebnis gezeigt wird. Das Bearbeitungsfeld Null wird aktualisiert, wenn sich der Mittelwert und die Hypothese ändern und das Kontrollkästchen Signifikanzniveau aktiviert ist.

   if( 0 == lstrcmp(lpcszNodeName, "mean") ) 
      _update_null(trGetN, true);
   if( 0 == lstrcmp(lpcszNodeName, "tail") ) 
      _update_null(trGetN);   
   if( 0 == lstrcmp(lpcszNodeName, "siglevel") ) 
      bOKEnable = _check_sig_level(trGetN, strErrMsg);
 
   _update_GUI(trGetN);
   _update_strErr(trGetN, strErrMsg);  
 
   return false;
  • OnetTest_before_execute()

Aktualisieren Sie den Funktionskörper, um die Bedienelemente in dem Dialogfeld zu zeigen/verbergen oder zu deaktivieren.

   StatTestWizCore* pstatwc = (StatTestWizCore*)get_xf_core_handler(trGetN.nXFCorePointer.nVal);
   ASSERT(pstatwc);
   trGetN.prob.Show = 1 - pstatwc->nStep;
   trGetN.prob.Enable = false;
 
   trGetN.null.Enable = false;
   trGetN.stat.Enable = false;
   trGetN.df.Enable = false;
   trGetN.tprob.Enable = false;
   trGetN.lcl.Enable = false;
   trGetN.ucl.Enable = false;

Klicken Sie auf die Schaltfläche Kompilieren, um die Datei zu kompilieren. Klicken Sie dann auf die Schaltfläche Zurück zum NSLF, um zum Dialog X-Funktionen erstellen zurückzukehren. Klicken Sie auf die Schaltfläche OXF-Datei speichern, um die X-Funktion zu speichern.

Schließen Sie Origin. Wenn Sie Origin dann starten, sehen Sie, dass ein neues Element Stat Test zum Origin-Menü Statistik: Hypothesentest hinzugefügt wurde.

Verwenden des Assistenten

Die folgenden Beispiele zeigen, wie der Assistent verwendet wird.

  1. Markieren Sie eine Spalte in dem Arbeitsblatt.
  2. Wählen Sie Statistik: Hypothesentest: Stat Test im Origin-Menü oder geben Sie den Befehl "StatTest -d" im Befehlsfenster ein. Das Dialogfeld Stat Test öffnet sich.
    Image:How_to_Create_a_Wizard_wiz1.png
  3. Klicken Sie auf die Schaltfläche Weiter. Das Dialogfeld Normality Test wird geöffnet. Das Ergebnis wird im Zweig Ausgabe gezeigt. Unten im Dialogfeld wird eine Schlussfolgerung gezogen.
    Image:How_to_Create_a_Wizard_wiz2.png
  4. Klicken Sie auf die Schaltfläche Weiter. Das Dialogfeld One-Sample t-test wird geöffnet. Das Ergebnis wird im Zweig Ausgabe gezeigt. Unten im Dialogfeld wird eine Schlussfolgerung gezogen. Das Ergebnis des Test auf Normalverteilung aus dem vorhergehenden Schritt wird oben gezeigt. Sie können auch die Einstellung im Dialogfeld ändern und die Änderung des Ergebnisses sehen.
    Image:How_to_Create_a_Wizard_wiz3.png
    Image:How_to_Create_a_Wizard_wiz3b.png
  5. Klicken Sie auf die Schaltfläche Fertigstellen, um den Assistenten zu beenden. Zwei Arbeitsblätter für die Ergebnisse werden erstellt.
    Image:How_to_Create_a_Wizard_wiz_Res1.png
    Image:How_to_Create_a_Wizard_wiz_Res2.png
English | Deutsch | 日本語