indVaRC = vc.getVaRC(var[-1, 0], p, c)
print("Running GAUSSIAN-THRESHOLD MODEL")
resultG = scipy.optimize.minimize(th.calibrateGaussian, 0.2, args=(myP, rhoTarget))
rhoG = resultG.x
el[1], ul[1], var[:, 1], es[:, 1] = th.oneFactorThresholdModel(
N, M, p, c, rhoG, nu, alpha, 0
)
gVaRC = vc.myVaRCY(var[-1, 1], p, c, rhoG, 0, 0)
print("Running WEIBULL-POISSON MIXTURE MODEL")
weibull = scipy.optimize.fsolve(
mix.poissonMixtureCalibrate, np.array([0.5, 0.01]), args=(myP, rhoTarget, 1)
)
a = weibull[0]
b = weibull[1]
M1, M2 = mix.calibrateVerify(a, b, myP, rhoTarget, 7)
el[2], ul[2], var[:, 2], es[:, 2] = mix.poissonMixtureSimulation(
N, M, c, a, b, alpha, 1
)
wVaRC = vc.myVaRCY(var[-1, 2], p, c, a, b, 5)
print("Running t-THRESHOLD MODEL. Caution: it's a bit slow!")
tModel = scipy.optimize.fsolve(
th.tCalibrate, np.array([0.2, 10]), args=(myP, rhoTarget, tDependenceTarget)
)
rhoT = tModel[0]
nu = tModel[1]
el[3], ul[3], var[:, 3], es[:, 3] = th.oneFactorThresholdModel(
N, M, p, c, rhoT, nu, alpha, 1
)
tVaRC = vc.myVaRCYT(var[-1, 3], p, c, rhoT, nu, 6)
# Print the results
M = 1000000
numberOfModels = 3
alpha = np.array([0.95, 0.97, 0.99, 0.995, 0.999, 0.9997, 0.9999])
# Set aside some memory
el = np.zeros([numberOfModels])
ul = np.zeros([numberOfModels])
var = np.zeros([len(alpha), numberOfModels])
es = np.zeros([len(alpha), numberOfModels])
cTime = np.zeros(numberOfModels)
a = np.zeros(numberOfModels)
b = np.zeros(numberOfModels)
M1 = np.zeros(numberOfModels)
M2 = np.zeros(numberOfModels)
print("Running BINOMIAL MODEL")
# (a) Calibrate
M1[0], M2[0] = mix.calibrateVerify(a[0], b[0], myP, myRho, 0)
# (b) Simulate
startTime = time.perf_counter()
el[0], ul[0], var[:, 0], es[:, 0] = bp.independentBinomialSimulation(N, M, p, c, alpha)
cTime[0] = time.perf_counter() - startTime
print("Running BETA-BINOMIAL MODEL")
# (a) Calibrate
a[1], b[1] = mix.betaCalibrate(myP, myRho)
M1[1], M2[1] = mix.calibrateVerify(a[1], b[1], myP, myRho, 1)
# (b) Simulate
startTime = time.perf_counter()
el[1], ul[1], var[:, 1], es[:, 1] = mix.betaBinomialSimulation(
N, M, c, a[1], b[1], alpha
)
cTime[1] = time.perf_counter() - startTime
print("Running LOGIT-NORMAL MODEL")
# =============================================
# 2/ Method-of-Moments Example
# =============================================
# Observed moments
dHat = np.mean(kVec / nVec)
vHat = np.var(kVec / nVec)
mList = np.array(['Beta', 'Logit', 'Probit', 'P-gamma', 'P-LN', 'P-WB'])
numModels = 6
x0 = np.array([[0.1, 0.2], [-1, 0.7], [-1, 0.7], [0.48, 0.005], [-1, 0.7],
[0.48, 0.005]])
M1 = np.zeros(numModels)
M2 = np.zeros(numModels)
dCorr = np.zeros(numModels)
mOrder = np.array([1, 2, 3, 5, 6, 7])
mixPara = np.zeros([numModels, 2])
for n in range(0, numModels):
mixPara[n, :] = scipy.optimize.fsolve(ac.mixtureMethodOfMoment,
x0[n, :],
args=(dHat, vHat, n))
M1[n], M2[n] = mix.calibrateVerify(mixPara[n, 0], mixPara[n, 1], dHat,
0.015, mOrder[n])
dCorr[n] = mix.defCorr(M1[n], M2[n])
print("Printing METHOD-OF-MOMENTS RESULTS")
print("Model\t M1\t M1Hat\t M2\t M2Hat\t p1\t p2\t RHO")
print("-----\t --\t -----\t --\t -----\t --\t --\t ---")
for n in range(0, numModels):
print("%s\t %0.2f\t %0.2f\t %0.2f\t %0.2f\t %0.2f\t %0.2f\t %0.3f" %
(mList[n], 1e4 * dHat, 1e4 * M1[n], 1e4 * np.sqrt(vHat), 1e4 *
np.sqrt(M2[n] - M1[n]**2), mixPara[n, 0], mixPara[n, 1], dCorr[n]))