def oneFactorTModel(N,M,p,c,rho,nu,alpha):
Y = getTY(N,M,p,rho,nu)
K = myT.ppf(p,nu)*np.ones((M,1))
lossIndicator = 1*np.less(Y,K)
lossDistribution = np.sort(np.dot(lossIndicator,c),axis=None)
el,ul,var,es=util.computeRiskMeasures(M,lossDistribution,alpha)
return el,ul,var,es
def oneFactorGaussianModel(N,M,p,c,rho,alpha):
Y = getGaussianY(N,M,p,rho)
K = norm.ppf(p)*np.ones((M,1))
lossIndicator = 1*np.less(Y,K)
lossDistribution = np.sort(np.dot(lossIndicator,c),axis=None)
el,ul,var,es=util.computeRiskMeasures(M,lossDistribution,alpha)
return el,ul,var,es
def betaBinomialSimulation(N, M, c, a, b, alpha):
Z = util.generateGamma(a, b, M)
pZ = np.transpose(np.tile(Z, (N, 1)))
U = np.random.uniform(0, 1, [M, N])
lossIndicator = 1 * np.less(U, pZ)
lossDistribution = np.sort(np.dot(lossIndicator, c), axis=None)
el, ul, var, es = util.computeRiskMeasures(M, lossDistribution, alpha)
return el, ul, var, es
def crPlusOneFactor(N, M, w, p, c, v, alpha):
S = np.random.gamma(v, 1 / v, [M])
wS = np.transpose(np.tile(1 - w + w * S, [N, 1]))
pS = np.tile(p, [M, 1]) * wS
H = np.random.poisson(pS, [M, N])
lossIndicator = 1 * np.greater_equal(H, 1)
lossDistribution = np.sort(np.dot(lossIndicator, c), axis=None)
el, ul, var, es = util.computeRiskMeasures(M, lossDistribution, alpha)
return el, ul, var, es
def poissonGammaSimulation(N, M, c, a, b, alpha):
lam = np.random.gamma(a, 1 / b, M)
H = np.zeros([M, N])
for m in range(0, M):
H[m, :] = np.random.poisson(lam[m], [N])
lossIndicator = 1 * np.greater_equal(H, 1)
lossDistribution = np.sort(np.dot(lossIndicator, c), axis=None)
el, ul, var, es = util.computeRiskMeasures(M, lossDistribution, alpha)
return el, ul, var, es
def mertonDirectSimulation(N, M, K, hatA, Omega, c, alpha):
Z = np.random.normal(0, 1, [M, N])
w, v = anp.eigh(Omega)
H = np.dot(v, np.sqrt(np.diag(w)))
A = np.tile(hatA, (M, 1)) + np.dot(Z, np.transpose(H))
lossIndicator = 1 * np.less(A, K)
lossDistribution = np.sort(np.dot(lossIndicator, c), axis=None)
el, ul, var, es = util.computeRiskMeasures(M, lossDistribution, alpha)
return el, ul, var, es
def mertonIndirectSimulation(N, M, p, Omega, c, alpha):
Z = np.random.normal(0, 1, [M, N])
w, v = anp.eigh(Omega)
H = np.dot(v, np.sqrt(np.diag(w)))
xi = np.dot(Z, np.transpose(H))
K = norm.ppf(p) * np.ones((M, 1))
lossIndicator = 1 * np.less(xi, K)
lossDistribution = np.sort(np.dot(lossIndicator, c), axis=None)
el, ul, var, es = util.computeRiskMeasures(M, lossDistribution, alpha)
return el, ul, var, es
def oneFactorThresholdModel(N,M,p,c,rho,nu,alpha,isT):
Y = getY(N,M,p,rho,nu,isT)
if isT==1:
K = myT.ppf(p,nu)*np.ones((M,1))
else:
K = norm.ppf(p)*np.ones((M,1))
lossIndicator = 1*np.less(Y,K)
lossDistribution = np.sort(np.dot(lossIndicator,c),axis=None)
el,ul,var,es=util.computeRiskMeasures(M,lossDistribution,alpha)
return el,ul,var,es
def oneFactorNVMModel(N, M, p, c, rho, myA, alpha, whichModel):
Y = getNVMY(N, M, rho, myA, whichModel)
invVector = np.zeros(N)
for n in range(0, N):
invVector[n] = nvmPpf(p[n], myA, whichModel)
K = invVector * np.ones((M, 1))
lossIndicator = 1 * np.less(Y, K)
lossDistribution = np.sort(np.dot(lossIndicator, c), axis=None)
el, ul, var, es = util.computeRiskMeasures(M, lossDistribution, alpha)
return el, ul, var, es
def poissonMixtureSimulation(N, M, c, a, b, alpha, whichModel):
if whichModel == 0:
lam = np.random.lognormal(a, b, M)
elif whichModel == 1:
lam = b * np.random.weibull(a, M)
H = np.zeros([M, N])
for m in range(0, M):
H[m, :] = np.random.poisson(lam[m], [N])
lossIndicator = 1 * np.greater_equal(H, 1)
lossDistribution = np.sort(np.dot(lossIndicator, c), axis=None)
el, ul, var, es = util.computeRiskMeasures(M, lossDistribution, alpha)
return el, ul, var, es
def logitProbitBinomialSimulation(N, M, c, mu, sigma, alpha, isLogit):
Z = np.random.normal(0, 1, M)
if isLogit == 1:
p = np.reciprocal(1 + np.exp(-(mu + sigma * Z)))
else:
p = norm.cdf(mu + sigma * Z)
pZ = np.transpose(np.tile(p, (N, 1)))
U = np.random.uniform(0, 1, [M, N])
lossIndicator = 1 * np.less(U, pZ)
lossDistribution = np.sort(np.dot(lossIndicator, c), axis=None)
el, ul, var, es = util.computeRiskMeasures(M, lossDistribution, alpha)
return el, ul, var, es
def mcThresholdIndDecomposition(N,M,S,p,c,myAlpha):
contributions = np.zeros([N,S,2])
var = np.zeros(S)
es = np.zeros(S)
for s in range(0,S):
print("Iteration: %d" % (s+1))
myLoss,myD = bp.independentBinomialLossDistribution(N,M,p,c,myAlpha,1)
el,ul,var[s],es[s]=util.computeRiskMeasures(M,myLoss,np.array([myAlpha]))
varVector = c*myD[np.dot(myD,c)==var[s],:]
esVector = c*myD[np.dot(myD,c)>=var[s],:]
contributions[:,s,0] = np.sum(varVector,0)/varVector.shape[0]
contributions[:,s,1] = np.sum(esVector,0)/esVector.shape[0]
return contributions,var,es
def crPlusMultifactor(N, M, wMat, p, c, aVec, alpha, rId):
K = len(aVec)
S = np.zeros([M, K])
for k in range(0, K):
S[:, k] = np.random.gamma(aVec[k], 1 / aVec[k], [M])
W = wMat[rId, :]
# Could replace tile with np.kron(W[:,0],np.ones([1,M])), but it's slow
wS = np.tile(W[:, 0], [M, 1]) + np.dot(S, np.transpose(W[:, 1:]))
pS = np.tile(p, [M, 1]) * wS
H = np.random.poisson(pS, [M, N])
lossIndicator = 1 * np.greater_equal(H, 1)
lossDistribution = np.sort(np.dot(lossIndicator, c), axis=None)
el, ul, var, es = util.computeRiskMeasures(M, lossDistribution, alpha)
return el, ul, var, es
def mcThresholdGDecomposition(N,M,S,p,c,rho,nu,isT,myAlpha):
contributions = np.zeros([N,S,2])
var = np.zeros(S)
es = np.zeros(S)
K = norm.ppf(p)*np.ones((M,1))
for s in range(0,S):
print("Iteration: %d" % (s+1))
Y = th.getY(N,M,p,rho,nu,isT)
myD = 1*np.less(Y,K)
myLoss = np.sort(np.dot(myD,c),axis=None)
el,ul,var[s],es[s]=util.computeRiskMeasures(M,myLoss,np.array([myAlpha]))
varVector = c*myD[np.dot(myD,c)==var[s],:]
esVector = c*myD[np.dot(myD,c)>=var[s],:]
contributions[:,s,0] = np.sum(varVector,0)/varVector.shape[0]
contributions[:,s,1] = np.sum(esVector,0)/esVector.shape[0]
return contributions,var,es
def independentBinomialSimulation(N, M, p, c, alpha):
lossDistribution = independentBinomialLossDistribution(N, M, p, c, alpha)
el, ul, var, es = util.computeRiskMeasures(M, lossDistribution, alpha)
return el, ul, var, es
