# -*- coding: utf-8 -*- """ Created on Wed June 24 15:24:51 2022 @authors: Alan.Mustafa@ieee.org, AHatemi@uaeu.ac.ae """ # -*- coding: utf-8 -*- #****************************************************************************** # Name of the program: PMCT2ES # Title of the program: Python Module for Cointegration Tests # with Two Endogenous Structural Shifts # The module provides also the cointegration vector with # two unknown breaks. For critical values see the # published paper (Hatemi-J, 2008, Empirical Economics). # Version: 001 # # This program is released under GNU General Public License, version 3. # # This program is free software: you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation, either version 3 of the License, or # (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program. If not, see . # # This software has been developed by Dr. Alan Mustafa under supervision of # Prof. Abdulnasser Hatemi-J (Hatemi-J, 2008). # Contacts: # - Dr. Alan Mustafa: Alan.Mustafa@ieee.org # - Prof. Abdulnasser Hatemi-J: AHatemi@uaeu.ac.ae # # Date: June 2022 # # © 2022 Dr. Alan Mustafa and Prof. Abdulnasser Hatemi-J # #****************************************************************************** # import threading import numpy as np import pandas as pd import os import math ####################################### import tkinter as tk # import time from tkinter.ttk import Progressbar from datetime import datetime from tkinter.filedialog import askopenfilename ############################################################################### # Start of GUI ############################################################################### #========================= functions ========================================= class create_window_menu_UI(tk.Frame): def __init__(self, master): tk.Frame.__init__(self, master) self.master = master #========================================================= GUI Row 0 ============================================ #============= Application Title -------------------------------------- #============= Adding a Blank Row -------------------------------------- self.lblTitle = tk.Label(self, text="Conducting Tests of Cointegration with Two Endogenous Structural Shifts", font=("Helvetica", 14)); # self.lblTitle.grid(row=0, column=1, columnspan=11, sticky="ns") self.lblTitle.grid(row=0, column=0, columnspan=12, sticky="ns") #========================================================= GUI Row 1 ============================================ #============= Drawing Horizontal Line -------------------------------- hr = tk.Frame(self,height=2,width=900,bg="green") hr.grid(row=1, column=0, columnspan=12, sticky="ew") #========================================================= GUI Row 2 ============================================ #============= Adding a Blank Row -------------------------------------- self.lblBlank = tk.Label(self, text=" ", font=("Helvetica", 8)) self.lblBlank.grid(row=2, column=0, columnspan=12, sticky="ew") #========================================================= GUI Row 3 ============================================ #============= Load My Data Button --------------------------------- self.btnLoadMydata = tk.Label(self, text="Load the Data Set", font=("Helvetica", 10)) self.btnLoadMydata.grid(row=3, column=0, sticky="e") var_DatasetFile = tk.StringVar() self.tbx_DatasetFile = tk.Entry(self, textvariable=var_DatasetFile, font=("Helvetica", 10), state="disabled", justify="center") self.tbx_DatasetFile.grid(row=3, column=1, columnspan=2, sticky="wns") self.btnSelectDataFile = tk.Button(self, text="Select the Data Set File (*.csv)", command=lambda: (var_DatasetFile.set(os.path.split(askopenfilename(filetypes=(("CSV Files", "*.csv"),), title="Select CSV File"))[1]), self.btnCalcPCTESS.config(state="normal")), font=("Helvetica", 10)) self.btnSelectDataFile.grid(row=3, column=3, columnspan=3, sticky="ew") #============= Message for Producing a Report -------------------------------- infoText = """A copy of the estimated results has been added to the same folder as the program resides in [BreakTest_rprt_YMD_Time.txt].""" self.txtFileRprtMsg = tk.Label(self, text=infoText, font=("Helvetica", 10, "italic"), anchor="nw", justify="left", wraplength=275, borderwidth=2, relief="groove") self.txtFileRprtMsg.grid(row=3, column=6, columnspan=4, rowspan=3, sticky="nse") #========================================================= GUI Row 4 ============================================ #============= Load My Data Button --------------------------------- self.lblMaxLag = tk.Label(self, text="Maximum Lag Order", font=("Helvetica", 10)) self.lblMaxLag.grid(row=4, column=0, sticky="e") var_maxLag = tk.StringVar(); self.tbx_maxLag = tk.Entry(self, textvariable=var_maxLag, font=("Helvetica", 10), justify="center") self.tbx_maxLag.insert(0,2) self.tbx_maxLag.grid(row=4, column=1, columnspan=2, sticky="wns") #============= Adding a Blank Cell ----------------------------------- self.lblEnterInt = tk.Label(self, text="Default lag is 2.", font=("Helvetica", 10, "italic"), anchor="w", justify="left") self.lblEnterInt.grid(row=4, column=3, columnspan=3, sticky="ew") #========================================================= GUI Row 5 ============================================ self.lblNotValidated = tk.Label(self, text=" ", font=("Helvetica", 8, "italic"), fg="#f00") self.lblNotValidated.grid(row=5, column=1, columnspan=2, sticky="ew") #========================================================= GUI Row 14 ============================================ #============= Button to Calculate the Cointegration -------------------------------- self.btnCalcPCTESS = tk.Button(self, text="Run the Test", command=lambda: validate_MaxLag (var_DatasetFile, var_maxLag, self), state="disabled", font=("Helvetica", 10)) self.btnCalcPCTESS.grid(row=6, column=3, columnspan=2, sticky="ew") self.btnRestartProg = tk.Button(self, text="Restart the Program", command=lambda: refresh(), font=("Helvetica", 10)) self.btnRestartProg.grid(row=6, column=6, columnspan=2, sticky="e") #============= Close the Module Button ------------------------------------------- self.btnExit = tk.Button(self, text="Close", command=self.master.destroy, font=("Helvetica", 10)) self.btnExit.grid(row=6, column=8, columnspan=2, sticky="ew") #================================================================================================================== #========================================================= GUI Row 7 ============================================ #================================================================================================================== #============= Printing Results and Credits --------------------------------------- #============= Drawing Horizontal Line -------------------------------- hr = tk.Frame(self,height=2,width=900,bg="green") hr.grid(row=8, column=0, columnspan=12, sticky="ew") #========================================================= GUI Row 8 ============================================ #============= Adding a Blank Cell ----------------------------------- self.lblBlank180 = tk.Label(self, text=" ", font=("Helvetica", 10), anchor="w", justify="left") self.lblBlank180.grid(row=9, column=0, sticky="w") #============= Output Message - Modified ADF Test --------------- self.msgOutputMsg_Modified_ADF_Test = tk.Message(self, text=" ", font=("Helvetica", 10), anchor="nw", justify="left") self.msgOutputMsg_Modified_ADF_Test.grid(row=9, column=1, columnspan=4, sticky="ew") #============= Adding a Blank Cell ----------------------------------- self.lblBlank181 = tk.Label(self, text=" ", font=("Helvetica", 10), anchor="w", justify="left") self.lblBlank181.grid(row=9, column=4, columnspan=2, sticky="ew") #============= Output Message - Modified Phillips Test --------------- self.msgOutputMsg_Modified_Phillips_Test = tk.Message(self, text=" ", font=("Helvetica", 10), anchor="nw", justify="left") self.msgOutputMsg_Modified_Phillips_Test.grid(row=9, column=6, columnspan=4, sticky="ew") #============= Adding a Blank Cell ----------------------------------- self.lblBlank182 = tk.Label(self, text=" ", font=("Helvetica", 10), anchor="w", justify="left") self.lblBlank182.grid(row=9, column=9, columnspan=3, sticky="ew") #========================================================= GUI Row 9 ============================================ #============= Adding a Blank Cell ----------------------------------- self.lblBlank190 = tk.Label(self, text=" ", font=("Helvetica", 10), anchor="w", justify="left") self.lblBlank190.grid(row=10, column=0, sticky="w") #============= Output Message - b_se_t --------------- self.msgOutputMsg_b_se_t = tk.Message(self, text=" ", font=("Helvetica", 10), anchor="nw", justify="left") self.msgOutputMsg_b_se_t.grid(row=10, column=1, columnspan=4, sticky="nsw") #============= Adding a Blank Cell ----------------------------------- self.lblBlank191 = tk.Label(self, text=" ", font=("Helvetica", 10), anchor="nw", justify="left") self.lblBlank191.grid(row=10, column=4, columnspan=2, sticky="ew") #============= Output Message - Models_X1 --------------- self.msgOutputMsg_Models_X1 = tk.Message(self, text=" ", font=("Helvetica", 10), anchor="nw", justify="left") self.msgOutputMsg_Models_X1.grid(row=10, column=6, columnspan=4, sticky="nsw") #============= Adding a Blank Cell ----------------------------------- self.lblBlank192 = tk.Label(self, text=" ", font=("Helvetica", 10), anchor="w", justify="left") self.lblBlank192.grid(row=10, column=9, columnsp=3, sticky="ew") #========================================================= GUI Row 10============================================ #============= Drawing Horizontal Line -------------------------------- hr = tk.Frame(self,height=2,width=900,bg="green") hr.grid(row=11, column=0, columnspan=12, sticky="w") #========================================================= GUI Row 11============================================ #============= Drawing Horizontal Line -------------------------------- hr = tk.Frame(self,height=2,width=900,bg="green") hr.grid(row=12, column=0, columnspan=12, sticky="ew") #========================================================= GUI Row 12============================================ #============= Output EndNote --------------------------------- self.msgEndNote = tk.Message(self, text=" ", font=("Helvetica", 8, "italic"), anchor="w", justify="left", bg="#d4d4d4", borderwidth=2, relief="groove") self.msgEndNote.bind("", lambda e: self.msgEndNote.configure(width=e.width)) self.msgEndNote.grid(row=13, column=0, columnspan=12, sticky="ew") ########################################################################################################################### # End of GUI # ########################################################################################################################### ############################################################################### ############################################################################### ############################################################################### ############################################################################### def validate_MaxLag(dataset_file,var_maxLag,self): # def validate_MaxLag(pb,dataset_file,var_maxLag,self): try: calc_BreakTest(dataset_file,var_maxLag,self) except ValueError: self.lblNotValidated.config(text="The entry is not an integer!"); ############################################################################### ############################################################################### ############################################################################### ############################################################################### def calc_BreakTest(dataset_file,var_maxLag,self): var_DatasetFile = dataset_file.get(); dataset = pd.read_csv(var_DatasetFile, header=None); #=============== creating Output Report File ============================== x = dataset.iloc[:, 1:].values; y = dataset.iloc[:, [0]].values; fileName = create_rprt_file(); calc_BreakTestMain(y,x,4,2,var_maxLag,self,fileName); EndNote(fileName,self); return; ################################################ def create_rprt_file(): #=============== creating Output Report File ============================== now = datetime.now() dt_string2 = now.strftime("%Y%m%d_%H%M%S") fileName = 'BreakTest_rprt' + "_" + dt_string2 + '.txt' output_rprt_file = open(fileName,'w') output_rprt_file.write('###############################################################################\n') output_rprt_file.write('# #\n') output_rprt_file.write('# COINTEGRATION TEST RESULTS #\n') output_rprt_file.write('# #\n') output_rprt_file.write('###############################################################################\n') output_rprt_file.close return(fileName); ################################################ def calc_BreakTestMain(y,x,model,choice,var_maxLag,self,fileName): #************************************************************************* #---- PROC MAIN #----FORMAT: call main(y,x,model,choice,k) #----INPUT: y - depend variable # x - data matrix for independent variables (first row is first observation) # model - choice for model # =2 C # =3 C/T # =4 C/S # choice - only in ADF test, =1 pre-specified AR lag # =2 AIC-chosen AR lag # =3 BIC-chosen AR lag # =4 downward-t-chosen AR lag # k - maximum lag for ADF test #----OUTPUT: print automatically Za*, breakpoint for Za*, Zt*, breakpoint for Zt* #, ADF*, breakpoint for ADF* and AR lag chosen for ADF* #----GLOBAL VARIABLES: none #----EXTERNAL PROCEDURES: adf, phillips #----NB: Constant included in regression #************************************************************************# #**************** Main procedure ******************* #************************************************************************# # pb.start(); n = y.shape[0]; k = int(var_maxLag.get()); begin = (np.rint(0.15 * n)).astype(int); final1 = (np.rint(0.7 * n)).astype(int); final2 = (np.rint(0.85 * n)).astype(int); temp1=999 * np.ones((final1-begin+1,final2-begin*2+1)); temp2=temp1.copy(); temp3=temp1.copy(); temp4=temp1.copy(); t1=begin; while t1 <= final1: t2 = t1 + begin; while t2 <= final2: dummy1 = np.concatenate((np.zeros((t1,1)), np.ones((n-(t1),1))), axis = 0); dummy2 = np.concatenate((np.zeros((t2,1)), np.ones((n-(t2),1))), axis = 0); # adjust regressors for different models if model==3: x1=np.concatenate((np.ones((n,1)),dummy1,dummy2,seqa(1,1,n),x), axis = 1); elif model==4: x1=np.concatenate((np.ones((n,1)),dummy1,dummy2,x,np.multiply(dummy1,x),np.multiply(dummy2,x)), axis = 1) elif model==2: x1=np.concatenate((np.ones((n,1)),dummy1,dummy2,x), axis = 1) #else: #nothing temp1[t1-begin,t2-begin*2],temp2[t1-begin,t2-begin*2]=adf(y,x1,k,choice); # compute Za or Zt for each t temp3[t1-begin,t2-begin*2],temp4[t1-begin,t2-begin*2]=phillips(y,x1); t2=t2+1; t1 = t1 +1; tstatminc = np.amin(temp1, axis = 0); minlag1ind = np.argmin(temp1, axis = 0); tstat = np.amin(tstatminc, axis = 0); bpt2 = np.where(tstatminc == np.amin(tstatminc))[0]; bpt1 = minlag1ind[bpt2]; breakpta1 = (bpt1+begin)/n; breakpta2 = (bpt2+begin)/n; lag=temp2[bpt1,bpt2]; print("******** Modified ADF Test ***********"); print("t-statistic = %.3f" %tstat); print("AR lag = ", lag); print("First break point(ADF) = %.3f" %breakpta1); print("Second break point(ADF) = %.3f" %breakpta2); print(" "); txtADF = ''; txtADF = txtADF + '============================\n'; txtADF = txtADF + '|\tModified ADF Test\t\t|\n'; txtADF = txtADF + '============================\n'; txtADF = txtADF + 't-statistic = %.3f\n' %tstat; txtADF = txtADF + 'AR lag = %.3f\n' %lag; txtADF = txtADF + 'First break point(ADF) = %.3f\n' %breakpta1; txtADF = txtADF + 'Second break point(ADF) = %.3f\n\n' %breakpta2; txtADF = txtADF + 'For critical values see Hatemi-J (2008).\n' %breakpta2; # For critical values see Hatemi-J (2008). txtADF = txtADF + '\n'; self.msgOutputMsg_Modified_ADF_Test["text"] = "%s" % (txtADF); #@ Phillips test @ zaminc = np.amin(temp3, axis = 0); minlag1ind = np.argmin(temp3, axis = 0); za = np.amin(zaminc, axis = 0); bpt2 = np.argmin(zaminc, axis = 0); bpt1 = minlag1ind[bpt2]; breakptza1 = (bpt1+begin)/n; breakptza2 = (bpt2+begin)/n; ztminc = np.amin(temp4, axis = 0); minlag1ind = np.argmin(temp4, axis = 0); zt = np.amin(ztminc, axis = 0); bpt2 = np.argmin(ztminc, axis = 0); bpt1 = minlag1ind[bpt2]; breakptzt1 = (bpt1+begin)/n; breakptzt2 = (bpt2+begin)/n; print("******** Modified Phillips Test ********"); print("Zt = %.3f" %zt); print("First breakpoint(Zt) = %.3f" %breakptzt1); print("Second breakpoint(Zt) = %.3f" %breakptzt2); print("Za = %.3f" %za); print("First breakpoint(Za) = %.3f" %breakptza1); print("Second breakpoint(Za) = %.3f" %breakptza2); print(" "); txtPhil = ''; txtPhil = txtPhil + '============================\n'; txtPhil = txtPhil + '|\tModified Zt and Za Tests\t|\n'; txtPhil = txtPhil + '============================\n'; txtPhil = txtPhil + 'Zt = %.3f\n' %zt; txtPhil = txtPhil + 'First breakpoint(Zt) = %.3f\n' %breakptzt1; txtPhil = txtPhil + 'Second breakpoint(Zt) = %.3f\n\n' %breakptzt2; txtPhil = txtPhil + 'Za = %.3f\n' %za; txtPhil = txtPhil + 'First breakpoint(Za) = %.3f\n' %breakptza1; txtPhil = txtPhil + 'Second breakpoint(Za) = %.3f\n' %breakptza2; txtPhil = txtPhil + '\n'; self.msgOutputMsg_Modified_Phillips_Test["text"] = "%s" % (txtPhil); dummy1=np.concatenate((np.zeros((bpt1+begin,1)),np.ones((n-(bpt1+begin),1))), axis = 0); dummy2=np.concatenate((np.zeros((bpt2+begin,1)),np.ones((n-(bpt2+begin),1))), axis = 0); # adjust regressors for different models if model==3: x1=np.concatenate((np.ones((n,1)),dummy1,dummy2,seqa(1,1,n),x), axis = 1); elif model==4: x1=np.concatenate((np.ones((n,1)),dummy1,dummy2,x,np.multiply(dummy1,x),np.multiply(dummy2,x)), axis = 1); elif model==2: x1=np.concatenate((np.ones((n,1)),dummy1,dummy2,x), axis = 1); #endif; print ("if model==3;"); print (" x1=ones(n,1)~dummy1~dummy2~seqa(1,1,n)~x;"); print ("elseif model==4;"); print (" x1=ones(n,1)~dummy1~dummy2~x~(dummy1).*x~(dummy2).*x;"); print ("elseif model==2;"); print (" x1=ones(n,1)~dummy1~dummy2~x;"); txtModel = ''; txtModel = txtModel + '==========================\n'; txtModel = txtModel + '|\t Model\t\t |\n'; txtModel = txtModel + '==========================\n'; # txtModel = txtModel + 'if model==3\n'; # txtModel = txtModel + ' x1=ones(n,1)~dummy1~dummy2~seqa(1,1,n)~x;\n'; # txtModel = txtModel + 'elseif model==4;\n'; txtModel = txtModel + 'x1=ones(n,1) ~ dummy1 ~ dummy2 ~ x ~ (dummy1) .* x ~ (dummy2) .* x;\n'; # txtModel = txtModel + 'elseif model==2;\n'; # txtModel = txtModel + ' x1=ones(n,1)~dummy1~dummy2~x;\n'; txtModel = txtModel + '\n'; self.msgOutputMsg_Models_X1["text"] = "%s" % (txtModel); b, e1,sig2,se = estimate(y,x1); np.set_printoptions(precision=3, suppress=True) b_divd_se = np.divide(b,se); b_se_bds = np.concatenate((b,se,b_divd_se), axis = 1); print("\n\n\tb\t\tse\t\tt\n\t______\t______\t______\n", b_se_bds); txt_b_se_t = ''; txt_b_se_t = txt_b_se_t + '============================\n'; txt_b_se_t = txt_b_se_t + '|\tEstimation Results \t|\n'; txt_b_se_t = txt_b_se_t + '============================\n'; txt_b_se_t = txt_b_se_t + 'b\tse\tt\n'; for i in range(0,b_se_bds.shape[0]): txt_b_se_t = txt_b_se_t + str(b_se_bds[i]).lstrip('[').rstrip(']') + '\n'; txt_b_se_t = txt_b_se_t + '\n'; self.msgOutputMsg_b_se_t["text"] = "%s" % (txt_b_se_t); ########################################################################### output_rprt_file = open(fileName,'a'); output_rprt_file.write(txtADF); output_rprt_file.write('\n\n'); output_rprt_file.write(txtPhil); output_rprt_file.write('\n\n'); output_rprt_file.write(txtModel); output_rprt_file.write('\n\n'); output_rprt_file.write(txt_b_se_t); output_rprt_file.write('\n\n'); output_rprt_file.close; ########################################################################### return; ################################################ def adf(y,x,kmax,choice): #/********************** PROC ADF ***************************** #** FORMAT #** { stat,lag } = adf(y,x) #** INPUT #** y - dependent variable #** x - independent variables #** OUTPUT #** stata - ADF statistic #** lag - the lag length #** GLOBAL VARIABLES: none #** EXTERNAL PROCEDURES: estimate #**********************************************************************/ #*************** Modified ADF for each breakpoint ******************** #**********************************************************************/ n = y.shape[0]; b,e,sig2,se=estimate(y,x); de=e[1:n]-e[0:n-1]; # difference of residuals ic=0; k=kmax; temp1=np.zeros((kmax+1,1)); temp2=np.zeros((kmax+1,1)); while k>=0: yde=de[k:n]; n1=yde.shape[0]; xe=e[k:n-1]; j=1; while j <= k: xe=np.concatenate((xe,de[k-j:n-1-j]), axis = 1); j=j+1; b,e1,sig2,se=estimate(yde,xe); if choice==1: # K is pre-specified temp1[k]=-1000; # set an random negative constant temp2[k]=b[0]/se[0]; break; elif choice==2: # K is determined by AIC aic = np.log((np.dot((np.transpose(e1)), e1))/n1) + 2 * (k + 2) / n1; ic=aic; elif choice==3: # K is determined by BIC bic=np.log((np.dot((np.transpose(e1)), e1))/n1) + (k+2)*np.log(n1)/n1; ic=bic; elif choice==4: # K is determined by downward t if abs(b[k]/se[k]) >= 1.96 or k==0: temp1[k]=-1000; # set an random negative constant temp2[k]=b[0]/se[0]; break; temp1[k]=ic; temp2[k]=b[0]/se[0]; k=k-1; lag = np.where(temp1 == np.amin(temp1))[0]; tstat=temp2[lag]; return(tstat,lag); ################################################ def phillips(y,x): #********************** PROC PHILLIPS ***************************** #** FORMAT #** { za,zt } = phillips(y,x) #** INPUT #** y - dependent variable #** x - independent variables #** OUTPUT #** za - the Phillips test statistic #** zt - the Phillips test statistic #** GLOBAL VARIABLES: none #**********************************************************************/ #*************** Modified Za or Zt for each breakpoint ******************** #**********************************************************************/ n = y.shape[0]; # OLS regression b = np.transpose(np.linalg.pinv(np.transpose(x))).dot(y); #e=y-x*b; e = y - (np.dot(x,b)); # OLS regression on residuals be = np.transpose(np.linalg.pinv(np.transpose(e[0:n-1]))).dot(e[1:n]); ue = e[1:n] - np.dot(e[0:n-1],be); # calculate bandwidth number nu=ue.shape[0]; bu = np.transpose(np.linalg.pinv(np.transpose(ue[0:nu-1]))).dot(ue[1:nu]); uu=ue[1:nu]-ue[0:nu-1]*bu; su=(np.power(uu,2)).mean(axis=0) a2=(4*np.power(bu,2)*su/(np.power((1-bu),8)))/(su/(np.power(1-bu,4))); bandwidth=1.3221*(np.power(a2*nu,0.2)); m=bandwidth; j=1; lemda=0; while j<=m: ueTue = np.dot((np.transpose(ue[0:nu-j])),ue[j:nu]); gama=ueTue/nu; c=j/m; Pi = math.pi; w=(75/((6*Pi*c)**2))*(math.sin(1.2*Pi*c)/(1.2*Pi*c) - math.cos(1.2*Pi*c)); lemda=lemda+w*gama; j=j+1; # calculate Za and Zt for each t p=np.sum(np.multiply(e[0:n-1],e[1:n])-lemda)/np.sum(np.power(e[0:n-1],2)); za=n*(p-1); sigma2 = 2 * lemda + (np.dot(np.transpose(ue),ue)/nu); s=sigma2/(np.dot(np.transpose(e[0:n-1]),e[0:n-1])); zt=(p-1)/np.sqrt(s); return (za,zt); ################################################ def estimate(y,x): m = np.linalg.inv(np.dot((np.transpose(x)),x)) #b=m*(x'y); b = np.dot(m, (np.dot((np.transpose(x)), y))); #e=y-x*b; e = y - np.dot(x,b); sig2 = np.dot((np.transpose(e)), e)/(y.shape[0] - x.shape[1]); se=np.sqrt(np.multiply((np.diag(m)),sig2)); se = np.transpose(se); return (b,e,sig2,se); ################################################ def seqa(start,inc,n): matrix = [n]; for i in range(start, n, inc): #print(matrix[idx:idx + inc]) matrix = np.concatenate(matrix[i+inc]); return(matrix); ################################################ def EndNote(fileName,self): output_rprt_file = open(fileName,'a'); output_rprt_file.write('===============================================================================\n'); output_rprt_file.write('| REFERENCES |\n'); output_rprt_file.write('| -Hatemi-J A. (2008) Tests for cointegration with two unknown regime shifts |\n'); output_rprt_file.write('| with an application to financial market integration, |\n'); output_rprt_file.write('| vol. 35(3), 497-505. |\n'); output_rprt_file.write('| |\n'); output_rprt_file.write('===============================================================================\n'); output_rprt_file.write('\n'); output_rprt_file.write('===============================================================================\n'); output_rprt_file.write('| ADDITIONAL INFORMATION |\n'); output_rprt_file.write('| |\n'); output_rprt_file.write('| This program code is the copyright of the authors. Applications are allowed |\n'); output_rprt_file.write('| only if proper reference and acknowledgments are provided. |\n'); output_rprt_file.write('| For non-Commercial applications only. No performance guarantee is |\n'); output_rprt_file.write('| made. Bug reports are welcome. If this code is used for research or in any |\n'); output_rprt_file.write('| other code, proper attribution needs to be included. |\n'); output_rprt_file.write('| |\n'); output_rprt_file.write('| © 2022 Dr. Alan Mustafa and Prof. Abdulnasser Hatemi-J |\n'); output_rprt_file.write('===============================================================================\n'); output_rprt_file.close; #-------------------------------------------------------------------------- txtEndNote = ""; txtEndNote = txtEndNote + """REFERENCE: - Hatemi-J A. (2008) Tests for cointegration with two unknown regime shifts with an application to financial market integration, Empirical Economics, vol. 35(3), 497-505. ADDITIONAL INFORMATION: This program code is the copyright of the authors. Applications are allowed only if proper reference and acknowledgments are provided. For non-Commercial applications only. No performance guarantee is made. Bug reports are welcome. If this code is used for research or in any other code, proper attribution needs to be included. © 2022 Dr. Alan Mustafa and Prof. Abdulnasser Hatemi-J """ self.msgEndNote["text"] = "%s" % (txtEndNote) return; ############################################################################### # End of Calculations: Calculating Options # ############################################################################### #In our main function, create the GUI and pass it to our App class def main(): global window window= tk.Tk() window.title("Tests of Cointegration with Two Endogenous Structural Shifts (PMCT2ES 1.0)") window.geometry('900x900+50+50') theWindow = create_window_menu_UI(window); theWindow.grid(row=0, column=1); window.mainloop() def refresh(): window.destroy() main() #Run the main function if __name__ == "__main__": main()