def impactoTmin(self,df_tmin):
cortes=f.all_cortes(self.stats)
izquierda = self.df_real[['CODCLAVEOPECTA','COSECHA']+f.all_cortes(self.df_real)].copy()
derecha = df_tmin[['CODCLAVEOPECTA','MTODESEMBOLSADO','Tmin','PDTmin','CANTmin','PRETmin']].copy()
df = pd.merge(left=izquierda, right=derecha, how='inner', left_on=['CODCLAVEOPECTA'], right_on=['CODCLAVEOPECTA'])
if cortes==['C_TODOS']:
df.loc[:,'C_TODOS']=''
df = df[cortes+['CODCLAVEOPECTA','COSECHA','MTODESEMBOLSADO','Tmin','PDTmin','CANTmin','PRETmin']]
Tmin = self.curvas[f.all_cortes(self.curvas)+['recuento']].copy()
for i in range(len(Tmin)):
temp = pd.merge(df, pd.DataFrame([Tmin.loc[i,:]]), how='inner', left_on=cortes, right_on=cortes)
Tmin.at[i,'Tmin_base'] = f.weighted_average(temp,'Tmin','MTODESEMBOLSADO')
Tmin.at[i,'delta_Tmin_pd'] = (f.weighted_average(temp,'PDTmin','MTODESEMBOLSADO')-Tmin.loc[i,'Tmin_base'])*(self.stats.loc[i,'scalar_pd']-1)*10
Tmin.at[i,'delta_Tmin_can'] = (f.weighted_average(temp,'CANTmin','MTODESEMBOLSADO')-Tmin.loc[i,'Tmin_base'])*(self.stats.loc[i,'scalar_can']-1)*10
Tmin.at[i,'delta_Tmin_pre'] = (f.weighted_average(temp,'PRETmin','MTODESEMBOLSADO')-Tmin.loc[i,'Tmin_base'])*(self.stats.loc[i,'scalar_pre']-1)*10
Tmin.at[i,'Tmin_final'] = Tmin.loc[i,'Tmin_base']+Tmin.loc[i,'delta_Tmin_pd']+Tmin.loc[i,'delta_Tmin_can']+Tmin.loc[i,'delta_Tmin_pre']
Tmin.at[i,'Monto'] = temp['MTODESEMBOLSADO'].sum()
self.Tmin = Tmin
Tmin_base_prom = f.weighted_average(self.Tmin,'Tmin_base','Monto')
delta_pd_prom = f.weighted_average(self.Tmin,'delta_Tmin_pd','Monto')
delta_can_prom = f.weighted_average(self.Tmin,'delta_Tmin_can','Monto')
delta_pre_prom = f.weighted_average(self.Tmin,'delta_Tmin_pre','Monto')
Tmin_final_prom = f.weighted_average(self.Tmin,'Tmin_final','Monto')
data = [['Tmin_base_prom', Tmin_base_prom], ['delta_pd_prom', delta_pd_prom], ['delta_can_prom', delta_can_prom], ['delta_pre_prom', delta_pre_prom], ['Tmin_final_prom', Tmin_final_prom]]
TminProm = pd.DataFrame(data, columns = ['Campo', 'Valor'])
self.TminProm = TminProm
def impactoTIR(self,df_tir):
cortes=f.all_cortes(self.stats)
izquierda = self.df_real[['CODCLAVEOPECTA','COSECHA']+f.all_cortes(self.df_real)].copy()
derecha2 = df_tir[['CODCLAVEOPECTA','ECAP','TIR','PDTIR','CANTIR','PRETIR']].copy()
df2 = pd.merge(left=izquierda, right=derecha2, how='inner', left_on=['CODCLAVEOPECTA'], right_on=['CODCLAVEOPECTA'])
if cortes==['C_TODOS']:
df2.loc[:,'C_TODOS']=''
df2 = df2[cortes+['CODCLAVEOPECTA','COSECHA','ECAP','TIR','PDTIR','CANTIR','PRETIR']]
TIR = self.curvas[f.all_cortes(self.curvas)+['recuento']].copy()
for i in range(len(TIR)):
temp = pd.merge(df2, pd.DataFrame([TIR.loc[i,:]]), how='inner', left_on=cortes, right_on=cortes)
TIR.at[i,'TIR_base'] = f.weighted_average(temp,'TIR','ECAP')
TIR.at[i,'delta_TIR_pd'] = (f.weighted_average(temp,'PDTIR','ECAP')-TIR.loc[i,'TIR_base'])*(self.stats.loc[i,'scalar_pd']-1)*10
TIR.at[i,'delta_TIR_can'] = (f.weighted_average(temp,'CANTIR','ECAP')-TIR.loc[i,'TIR_base'])*(self.stats.loc[i,'scalar_can']-1)*10
TIR.at[i,'delta_TIR_pre'] = (f.weighted_average(temp,'PRETIR','ECAP')-TIR.loc[i,'TIR_base'])*(self.stats.loc[i,'scalar_pre']-1)*10
TIR.at[i,'TIR_final'] = TIR.loc[i,'TIR_base']+TIR.loc[i,'delta_TIR_pd']+TIR.loc[i,'delta_TIR_can']+TIR.loc[i,'delta_TIR_pre']
TIR.at[i,'Capital promedio'] = temp['ECAP'].sum()
self.TIR = TIR
TIR_base_prom = f.weighted_average(self.TIR,'TIR_base','Capital promedio')
delta_pd_prom = f.weighted_average(self.TIR,'delta_TIR_pd','Capital promedio')
delta_can_prom = f.weighted_average(self.TIR,'delta_TIR_can','Capital promedio')
delta_pre_prom = f.weighted_average(self.TIR,'delta_TIR_pre','Capital promedio')
TIR_final_prom = f.weighted_average(self.TIR,'TIR_final','Capital promedio')
data = [['TIR_base_prom', TIR_base_prom], ['delta_pd_prom', delta_pd_prom], ['delta_can_prom', delta_can_prom], ['delta_pre_prom', delta_pre_prom], ['TIR_final_prom', TIR_final_prom]]
TIRProm = pd.DataFrame(data, columns = ['Campo', 'Valor'])
self.TIRProm = TIRProm
def __init__(self,
df_real,
df_teorico,
mincosecha='',
maxcosecha='',
completar=True):
if completar == True:
izquierda = df_real[
['CODCLAVEOPECTA', 'COSECHA', 'MAXMADPYG', 'MTODESEMBOLSADO'] +
f.all_cortes(df_real)].copy()
df_teorico = pd.merge(left=izquierda,
right=df_teorico,
how='inner',
left_on=['CODCLAVEOPECTA'],
right_on=['CODCLAVEOPECTA'])
izquierda = df_teorico[['CODCLAVEOPECTA']].copy()
df_real = pd.merge(left=izquierda,
right=df_real,
how='inner',
left_on=['CODCLAVEOPECTA'],
right_on=['CODCLAVEOPECTA'])
OutputsNoRevolventeReal.__init__(self,
df=df_real,
mincosecha=mincosecha,
maxcosecha=maxcosecha)
OutputsNoRevolventeTeorico.__init__(self,
df=df_teorico,
mincosecha=mincosecha,
maxcosecha=maxcosecha)
def MAE(self,texto,optimo=False):
temp = self.stats.sort_values(by=['MAE_'+texto], ascending=True)
temp = temp.reset_index()
cortes_temp = f.all_cortes(self.stats)
values=temp['MAE_'+texto] #1
if optimo==True:
values2=temp['MAEop_'+texto]
description = [] #2
for i in range(len(temp)):
a=''
for j in cortes_temp:
a=a+str(j)[2:]+' '+str(temp[j][i])+'; '
description.append(a[0:-2])
position = np.arange(len(description)) #3
bar1 = plt.barh(position,values,color='orange',edgecolor='black',height=0.5,label='MAE')
if optimo==True:
bar2 = plt.barh(position,values2,color='blue',edgecolor='black',height=0.5,label='MAE óptimo')
plt.yticks(position, description, fontsize=12)
plt.xticks(fontsize=12)
plt.xlabel('MAE', fontsize=12)
plt.ylabel('Grupo', fontsize=12)
plt.title(texto+': MAE por grupos',fontsize=16)
plt.legend()
plt.show()
def __init__(
self,
df,
mincosecha='',
maxcosecha=''
): #se insume un dataframe y (opcionalmente) filtros por cosechas
df_real = df
#Se coloca las curvas en una sola celda (por temas de orden)
df_real['prepagos'] = pd.DataFrame({
'pd':
df_real.iloc[:,
f.encontrar_encabezado(df_real, 'PREPAGO1'):f.
encontrar_encabezado(df_real, 'MTODESEMBOLSADO1')].
values.tolist()
})
df_real['desembolso'] = pd.DataFrame({
'pd':
df_real.iloc[:,
f.encontrar_encabezado(df_real, 'MTODESEMBOLSADO1'):f.
encontrar_encabezado(df_real, 'SALDOPROM1')].values.
tolist()
})
#Se selecciona solo los campos relevantes y se filtra por cosecha
df_real = df_real[f.all_cortes(df_real) + [
'CODCLAVEOPECTA', 'COSECHA', 'FAIL_TYPE', 'SURVIVAL', 'MAXMAD',
'prepagos', 'desembolso'
]]
if mincosecha != '':
df_real = df_real[df_real['COSECHA'] >= mincosecha]
if maxcosecha != '':
df_real = df_real[df_real['COSECHA'] <= maxcosecha]
self.df_real = df_real
def __init__(self,df,mincosecha='',maxcosecha=''): #se insume un documento de Excel
#tranformar la data de las hojas del excel en dataframes
df_real = df
#colocar las curvas en una sola celda
df_real['saldo'] = pd.DataFrame({'pd':df_real.iloc[:,f.encontrar_encabezado(df_real,'SALDOPROM1'):f.encontrar_encabezado(df_real,'IF1')].values.tolist()})
df_real['if'] = pd.DataFrame({'pd':df_real.iloc[:,f.encontrar_encabezado(df_real,'IF1'):f.encontrar_encabezado(df_real,'EF1')].values.tolist()})
df_real['ef'] = pd.DataFrame({'pd':df_real.iloc[:,f.encontrar_encabezado(df_real,'EF1'):f.encontrar_encabezado(df_real,'saldo')].values.tolist()})#'PROVISION1')].values.tolist()})
#df_real['pe'] = pd.DataFrame({'pd':df_real.iloc[:,f.encontrar_encabezado(df_real,'PROVISION1'):f.encontrar_encabezado(df_real,'saldo')].values.tolist()})
#seleccionar solo la data relevante
df_real = df_real[f.all_cortes(df_real)+['CODCLAVEOPECTA','COSECHA','MAXMADPYG','MTODESEMBOLSADO','if','ef','saldo']]#,'pe']]
if mincosecha!='':
df_real = df_real[df_real['COSECHA']>=mincosecha]
if maxcosecha!='':
df_real = df_real[df_real['COSECHA']<=maxcosecha]
self.df_real = df_real
def plotear(self, texto):
cortes_temp = f.all_cortes(self.curvas)
for i in range(len(self.curvas)):
z = []
for j in range(len(self.curvas[texto + '_real'][i])):
z.append(j + 1)
a = ''
for j in cortes_temp:
a = a + str(j)[2:] + ' ' + str(self.curvas[j][i]) + ' y '
plt.xlabel('Periodo', fontsize=12)
plt.ylabel(texto, fontsize=12)
plt.title(texto + ': curva real vs. teórico para ' + a[0:-3],
fontsize=16)
r = self.curvas[texto + '_real'][i]
plt.plot(z, r, label='real')
t = self.curvas[texto + '_teorico'][i]
plt.plot(z, t, label='teórico')
plt.plot(0)
plt.legend(fontsize=10)
plt.show()
def __init__(self,
df,
mincosecha='',
maxcosecha=''): #se insume un documento de Excel
df_teorico = df
#Se coloca las curvas en una sola celda (por temas de orden)
df_teorico['pd_marginal'] = pd.DataFrame({
'pd':
df_teorico.iloc[:,
f.encontrar_encabezado(df_teorico, 'PD1'):f.
encontrar_encabezado(df_teorico, 'CAN1')].values.
tolist()
})
df_teorico['can_marginal'] = pd.DataFrame({
'pd':
df_teorico.iloc[:,
f.encontrar_encabezado(df_teorico, 'CAN1'):f.
encontrar_encabezado(df_teorico, 'PRE1')].values.
tolist()
})
df_teorico['pre_marginal'] = pd.DataFrame({
'pd':
df_teorico.iloc[:,
f.encontrar_encabezado(df_teorico, 'PRE1'):f.
encontrar_encabezado(df_teorico, 'SALDOPROM1')].
values.tolist()
})
#Se selecciona solo los campos relevantes y se filtra por cosecha
df_teorico = df_teorico[f.all_cortes(df_teorico) + [
'CODCLAVEOPECTA', 'COSECHA', 'MAXMAD', 'MTODESEMBOLSADO',
'pd_marginal', 'can_marginal', 'pre_marginal'
]]
if mincosecha != '':
df_teorico = df_teorico[df_teorico['COSECHA'] >= mincosecha]
if maxcosecha != '':
df_teorico = df_teorico[df_teorico['COSECHA'] <= maxcosecha]
self.df_teorico = df_teorico
def condensar(self, cortes=[]):
OutputsNoRevolventeReal.condensar(self, cortes)
OutputsNoRevolventeTeorico.condensar(self, cortes)
curvas = pd.merge(left=self.curvasR,
right=self.curvasT,
how='left',
left_on=f.all_cortes(self.curvasR),
right_on=f.all_cortes(self.curvasT))
curvas = curvas.rename(columns={
'recuento_x': 'recuento'
}).drop('recuento_y', 1)
curvas = curvas.rename(columns={'monto_x': 'monto'}).drop('monto_y', 1)
ratios = curvas[f.all_cortes(curvas) + ['recuento', 'monto']].copy()
niveles = curvas[f.all_cortes(curvas) + ['recuento', 'monto']].copy()
for i in range(len(curvas)):
l = min(len(curvas.loc[i, 'if_real']),
len(curvas.loc[i, 'if_teorico']))
curvas.at[i, 'if_real'] = curvas.loc[i, 'if_real'].copy()[:l]
curvas.at[i, 'if_teorico'] = curvas.loc[i, 'if_teorico'].copy()[:l]
l = min(len(curvas.loc[i, 'ef_real']),
len(curvas.loc[i, 'ef_teorico']))
curvas.at[i, 'ef_real'] = curvas.loc[i, 'ef_real'].copy()[:l]
curvas.at[i, 'ef_teorico'] = curvas.loc[i, 'ef_teorico'].copy()[:l]
#l=min(len(curvas.loc[i, 'pe_real']),len(curvas.loc[i, 'pe_teorico']))
#curvas.at[i, 'pe_real']=curvas.loc[i, 'pe_real'].copy()[:l]
#curvas.at[i, 'pe_teorico']=curvas.loc[i, 'pe_teorico'].copy()[:l]
l = min(len(curvas.loc[i, 'saldo_real']),
len(curvas.loc[i, 'saldo_teorico']))
curvas.at[i, 'saldo_real'] = curvas.loc[i, 'saldo_real'].copy()[:l]
curvas.at[i,
'saldo_teorico'] = curvas.loc[i,
'saldo_teorico'].copy()[:l]
ratios.at[i, 'r_if_real'] = round(
((sum(curvas.loc[i, 'if_real']) /
sum(curvas.loc[i, 'saldo_real']))) * 12, 6) * 100
ratios.at[i, 'r_ef_real'] = round(
((sum(curvas.loc[i, 'ef_real']) /
sum(curvas.loc[i, 'saldo_real']))) * 12, 6) * 100
ratios.at[i, 'r_spread_bruto_real'] = ratios.at[
i, 'r_if_real'] + ratios.at[i, 'r_ef_real']
#ratios.at[i,'r_pe_real'] = round(((sum(curvas.loc[i, 'pe_real'])/sum(curvas.loc[i, 'saldo_real'])))*12,6)*100
#ratios.at[i,'r_spread_neto_real'] = ratios.at[i,'r_spread_bruto_real']-ratios.at[i,'r_pe_real']
ratios.at[i, 'r_if_teorico'] = round(
((sum(curvas.loc[i, 'if_teorico']) /
sum(curvas.loc[i, 'saldo_teorico']))) * 12, 6) * 100
ratios.at[i, 'r_ef_teorico'] = round(
((sum(curvas.loc[i, 'ef_teorico']) /
sum(curvas.loc[i, 'saldo_teorico']))) * 12, 6) * 100
ratios.at[i, 'r_spread_bruto_teorico'] = ratios.at[
i, 'r_if_teorico'] + ratios.at[i, 'r_ef_teorico']
#ratios.at[i,'r_pe_teorico'] = round(((sum(curvas.loc[i, 'pe_teorico'])/sum(curvas.loc[i, 'saldo_teorico'])))*12,6)*100
#ratios.at[i,'r_spread_neto_teorico'] = ratios.at[i,'r_spread_bruto_teorico']-ratios.at[i,'r_pe_teorico']
niveles.at[i, 'n_if_real'] = round(sum(curvas.loc[i, 'if_real']),
0)
niveles.at[i, 'n_ef_real'] = round(sum(curvas.loc[i, 'ef_real']),
0)
#niveles.at[i,'n_pe_real'] = round(sum(curvas.loc[i, 'pe_real']),0)
niveles.at[i, 'n_saldo_real'] = round(
sum(curvas.loc[i, 'saldo_real']), 0)
niveles.at[i, 'n_if_teorico'] = round(
sum(curvas.loc[i, 'if_teorico']), 0)
niveles.at[i, 'n_ef_teorico'] = round(
sum(curvas.loc[i, 'ef_teorico']), 0)
#niveles.at[i,'n_pe_teorico'] = round(sum(curvas.loc[i, 'pe_teorico']),0)
niveles.at[i, 'n_saldo_teorico'] = round(
sum(curvas.loc[i, 'saldo_teorico']), 0)
self.curvas = curvas
self.ratios = ratios
self.niveles = niveles
def condensar(self,cortes=[]):
InputsNoRevolventeReal.condensar(self,cortes)
InputsNoRevolventeTeorico.condensar(self,cortes)
curvas = pd.merge(left=self.curvasR, right=self.curvasT, how='left', left_on=f.all_cortes(self.curvasR), right_on=f.all_cortes(self.curvasT))
#curvas['check']=curvas['recuento_x']-curvas['recuento_y']
curvas = curvas.rename(columns={'recuento_x':'recuento'}).drop('recuento_y',1)
stats = curvas[f.all_cortes(curvas)+['recuento']].copy()
promedios = curvas[f.all_cortes(curvas)+['recuento']].copy()
#intervalos
ci_pd = curvas[f.all_cortes(curvas)+['recuento']].copy()
ci_can = curvas[f.all_cortes(curvas)+['recuento']].copy()
ci_pre = curvas[f.all_cortes(curvas)+['recuento']].copy()
for ci in [ci_pd,ci_can,ci_pre]:
ci['y_real']=''
ci['y_pred']=''
ci['CI:5.0-95.0']=''
ci['CI:5.0-95.0_u']=''
ci['CI:2.5-97.5']=''
ci['CI:2.5-97.5_u']=''
ci['CI:0.5-99.5']=''
ci['CI:0.5-99.5_u']=''
for i in range(len(curvas)):
l=min(len(curvas.loc[i, 'pd_real']),len(curvas.loc[i, 'pd_teorico']))
curvas.at[i, 'pd_real']=curvas.loc[i, 'pd_real'].copy()[:l]
curvas.at[i, 'pd_teorico']=curvas.loc[i, 'pd_teorico'].copy()[:l]
stats.at[i,'MAE_pd'] = mean_absolute_error(curvas.loc[i, 'pd_real'], curvas.loc[i, 'pd_teorico'])
#intervalos
ci_pd.at[i, 'y_real']=curvas.at[i, 'pd_real'].copy()
ci_pd.at[i, 'y_pred']=curvas.at[i, 'pd_teorico'].copy()
ci_pd.at[i, 'CI:5.0-95.0']=curvas.at[i, 'pd_real'].copy()
ci_pd.at[i, 'CI:5.0-95.0_u']=curvas.at[i, 'pd_real'].copy()
ci_pd.at[i, 'CI:2.5-97.5']=curvas.at[i, 'pd_real'].copy()
ci_pd.at[i, 'CI:2.5-97.5_u']=curvas.at[i, 'pd_real'].copy()
ci_pd.at[i, 'CI:0.5-99.5']=curvas.at[i, 'pd_real'].copy()
ci_pd.at[i, 'CI:0.5-99.5_u']=curvas.at[i, 'pd_real'].copy()
for j in range(l):
p = curvas.at[i, 'pd_teorico'][j]/100
n = self.nT.at[i, 'pd_teorico'][j]
sd = (p*(1-p)/n)**0.5
ci_pd.at[i, 'CI:5.0-95.0'][j]=round((p-sd*1.645)*100,4)
ci_pd.at[i, 'CI:5.0-95.0_u'][j]=round((p+sd*1.645)*100,4)
ci_pd.at[i, 'CI:2.5-97.5'][j]=round((p-sd*1.96)*100,4)
ci_pd.at[i, 'CI:2.5-97.5_u'][j]=round((p+sd*1.96)*100,4)
ci_pd.at[i, 'CI:0.5-99.5'][j]=round((p-sd*2.575)*100,4)
ci_pd.at[i, 'CI:0.5-99.5_u'][j]=round((p+sd*2.575)*100,4)
l=min(len(curvas.loc[i, 'can_real']),len(curvas.loc[i, 'can_teorico']))
curvas.at[i, 'can_real']=curvas.loc[i, 'can_real'].copy()[:l]
curvas.at[i, 'can_teorico']=curvas.loc[i, 'can_teorico'].copy()[:l]
stats.at[i,'MAE_can'] = mean_absolute_error(curvas.loc[i, 'can_real'], curvas.loc[i, 'can_teorico'])
#intervalos
ci_can.at[i, 'y_real']=curvas.at[i, 'can_real'].copy()
ci_can.at[i, 'y_pred']=curvas.at[i, 'can_teorico'].copy()
ci_can.at[i, 'CI:5.0-95.0']=curvas.at[i, 'can_real'].copy()
ci_can.at[i, 'CI:5.0-95.0_u']=curvas.at[i, 'can_real'].copy()
ci_can.at[i, 'CI:2.5-97.5']=curvas.at[i, 'can_real'].copy()
ci_can.at[i, 'CI:2.5-97.5_u']=curvas.at[i, 'can_real'].copy()
ci_can.at[i, 'CI:0.5-99.5']=curvas.at[i, 'can_real'].copy()
ci_can.at[i, 'CI:0.5-99.5_u']=curvas.at[i, 'can_real'].copy()
for j in range(l):
p = curvas.at[i, 'can_teorico'][j]/100
n = self.nT.at[i, 'can_teorico'][j]
sd = (p*(1-p)/n)**0.5
ci_can.at[i, 'CI:5.0-95.0'][j]=round((p-sd*1.645)*100,4)
ci_can.at[i, 'CI:5.0-95.0_u'][j]=round((p+sd*1.645)*100,4)
ci_can.at[i, 'CI:2.5-97.5'][j]=round((p-sd*1.96)*100,4)
ci_can.at[i, 'CI:2.5-97.5_u'][j]=round((p+sd*1.96)*100,4)
ci_can.at[i, 'CI:0.5-99.5'][j]=round((p-sd*2.575)*100,4)
ci_can.at[i, 'CI:0.5-99.5_u'][j]=round((p+sd*2.575)*100,4)
l=min(len(curvas.loc[i, 'pre_real']),len(curvas.loc[i, 'pre_teorico']))
curvas.at[i, 'pre_real']=curvas.loc[i, 'pre_real'].copy()[:l]
curvas.at[i, 'pre_teorico']=curvas.loc[i, 'pre_teorico'].copy()[:l]
stats.at[i,'MAE_pre'] = mean_absolute_error(curvas.loc[i, 'pre_real'], curvas.loc[i, 'pre_teorico'])
#intervalos
ci_pre.at[i, 'y_real']=curvas.at[i, 'pre_real'].copy()
ci_pre.at[i, 'y_pred']=curvas.at[i, 'pre_teorico'].copy()
ci_pre.at[i, 'CI:5.0-95.0']=curvas.at[i, 'pre_real'].copy()
ci_pre.at[i, 'CI:5.0-95.0_u']=curvas.at[i, 'pre_real'].copy()
ci_pre.at[i, 'CI:2.5-97.5']=curvas.at[i, 'pre_real'].copy()
ci_pre.at[i, 'CI:2.5-97.5_u']=curvas.at[i, 'pre_real'].copy()
ci_pre.at[i, 'CI:0.5-99.5']=curvas.at[i, 'pre_real'].copy()
ci_pre.at[i, 'CI:0.5-99.5_u']=curvas.at[i, 'pre_real'].copy()
for j in range(l):
p = curvas.at[i, 'pre_teorico'][j]/100
n = self.nT.at[i, 'pre_teorico'][j]
sd = (p*(1-p)/n)**0.5
ci_pre.at[i, 'CI:5.0-95.0'][j]=round((p-sd*1.645)*100,4)
ci_pre.at[i, 'CI:5.0-95.0_u'][j]=round((p+sd*1.645)*100,4)
ci_pre.at[i, 'CI:2.5-97.5'][j]=round((p-sd*1.96)*100,4)
ci_pre.at[i, 'CI:2.5-97.5_u'][j]=round((p+sd*1.96)*100,4)
ci_pre.at[i, 'CI:0.5-99.5'][j]=round((p-sd*2.575)*100,4)
ci_pre.at[i, 'CI:0.5-99.5_u'][j]=round((p+sd*2.575)*100,4)
promedios.at[i, 'pd_real'] = sum(curvas.at[i, 'pd_real'])/len(curvas.at[i, 'pd_real'])
promedios.at[i, 'can_real'] = sum(curvas.at[i, 'can_real'])/len(curvas.at[i, 'can_real'])
promedios.at[i, 'pre_real'] = sum(curvas.at[i, 'pre_real'])/len(curvas.at[i, 'pre_real'])
promedios.at[i, 'pd_teorico'] = sum(curvas.at[i, 'pd_teorico'])/len(curvas.at[i, 'pd_teorico'])
promedios.at[i, 'can_teorico'] = sum(curvas.at[i, 'can_teorico'])/len(curvas.at[i, 'can_teorico'])
promedios.at[i, 'pre_teorico'] = sum(curvas.at[i, 'pre_teorico'])/len(curvas.at[i, 'pre_teorico'])
self.curvas = curvas
self.stats = stats
self.promedios = promedios
self.ci_pd = ci_pd
self.ci_can = ci_can
self.ci_pre = ci_pre
